It
is my pleasure to share with you my recent achievement. Now I’m IEEE
Computer Society Certified Software Development Professional CSDP.
The CSDP credential is intended for mid-career software development
professionals that want to confirm their proficiency of standard
software development practices and advance in their careers.
Certified Software Development Professional
should:
- Possesses fundamental knowledge and understanding of computing
principles and concepts and their application to the definition,
design, construction, testing of software.
- Be able to apply design principles with technical and economic
tradeoffs to modules, subsystems, and systems in accordance with
standards of practice, specifications, and principles of behavior of
software as required to perform the functions as stated in the
software requirements.
- Has met the IEEE CS CSDP education, experience, and examination
requirements.
How to become an CSDP:
- Application Steps
- Obtain CSDP candidate brochure from IEEE Computer Society
http://www.computer.org/certification/
- Review requirements
- Complete application
- Send completed application to IEEE CS by deadline with fee
- Acknowledgement of payment
- Review of application
- If accepted, authorization to test sent to candidate
- Requirements for Certification
- Education: (need at least one)
- You have a bachelor’s degree
- You are a CSDA certificate holder
- You are an educator at the post-baccalaureate level
- You are a full member of the IEEE
- Experience: (need at least one)
- You have an advanced degree in software engineering and at
least two years (about 3,500 hrs) of experience in software
engineering/development
- You have at least four years (about 7,000 hrs) experience in
software engineering/development
- Preparation for Examination
- Depends on level of expertise in areas covered by Body of
Knowledge
- Focus on areas needing the most review
- Study from the suggested reference material
- Can take a refresher course (see CSDP website)
- Unless your background covers most of the Body of Knowledge,
allow three months of 2-4 hours a week for study
- Last week: assemble test access materials
- Examination
- Length: 4 hours
- Closed book, computer based
- At a Prometric training center (in Egypt only
AMIDEAST
Cairo branch)
- Format
• 180 multiple-choice questions that are based on concepts and
experiences that should be familiar to a proficient software
engineering professional with 7,000 or more hours of experience.
The topic areas are grouped by question deve lopment into
domains. The percentage range of questions in each area is as
follows:
- Business Practices and Engineering Economics (3–4%)
- Software Requirements (13–15%)
- Software Design (22–24%)
- Software Construction (10–12%)
- Software Testing (15–17%)
- Software Maintenance (3–5%)
- Software Configuration Management (3–4%)
- Software Engineering Management (10–12%)
- Software Engineering Process (2–4%)
- Software Engineering Tools and Methods (2–4%)
- Software Quality (6–8%)
General References :
- Software Engineering: A Practitioner’s Approach, Latest ed.,
Pressman, Roger S., New York, New York: McGraw-Hill.
- Software Engineering, Sommerville, I., Latest ed.
Reading, Massachusetts: Addison-Wesley.
- SE Body of knowledge http://www.swebok.org
- Online review course
http://www.computer.org/certification/DistanceLearning/index.htm
- Yahoo study group http://groups.yahoo.com/group/ieee_csdp/
- Software Engineering Vol. 1: The Development Process, 2nd
Edition.
Dorfman, M. & Thayer, R., editors,
Los Alamitos, California: IEEE Computer Society Press, 2002.
- Software Engineering Vol. 2: The Supporting Processes, 2nd
Edition.
Thayer, R. and M. Christensen, editors,
Los Alamitos,California: IEEE Computer Society Press, 2002.
- IEEE Software Engineering Collection, 1999, vols. 1-4.
Piscataway, New Jersey: IEEE.
Comprehensive Reading List :
- “Goal-Question-Metric (GQM) Approach” | Software Tech News, vol.
11, no. 4, Dec. 2008
- A Specifier’s Introduction to Formal Methods | Jeannette M. Wing
| Computer, vol. 23, no. 9, Sept. 1990, pp.10-23
- Algebraic Structures | Alex Lopez-Ortiz | Alex-Lopez Ortiz web
page
- Applied Statistics and Probability for Engineers, 4th Edition |
Douglas C. Montgomery and George C. Runger | Wiley
- Applying Formal Specifications to Real-World Software
Development | Girish Keshav Palshikar | IEEE Software, vol. 18,
no. 6, Nov. 2001, pp. 89-9.7
- Balancing Agility and Discipline: A Guide for the Perplexed |
Barry Boehm and Richard Turner | Addison Wesley
- Code Complete, 2nd Edition | Steve McConnell | Microsoft Press
- Computer Algorithms, 2nd Edition | Ellis Horowitz, Sartaj Sahni,
and Sanguthevar Rajasekaran | Silicon Press
- Computer Science: An Overview, 10th Edition | J. Glenn
Brookshear | Addison Wesley
- Computer Security: Art and Science | Matt Bishop | Addison
Wesley
- Configuration Management Principles and Practices | Anne Mette
Jonassen Hass | Addison Wesley
- Design Patterns: Elements of Reusable Object-Oriented Software |
Erich Gamma et al | Addison Wesley
- Discrete Mathematics and its Applications, 6th Edition | Kenneth
Rosen | McGraw-Hill
- Documenting Software Architectures: Views and Beyond | Paul
Clements et al | Addison Wesley
- Engineering by Design, 2nd Edition | Gerard Voland | Prentice
Hall
- Executable UML: A Foundation for Model-Driven Architecture |
Stephen J. Mellor and Marc J. Balcer | Addison Wesley
- Fundamental of Obj ect-Oriented Design in UML, 2nd Edition |
Meilir Page-Jones | Addison Wesley
- Guide to the Software Engineering Body of Knowledge | CS Press
- IEEE-CS/ACM Joint Task Force on Software Engineering Ethics and
Professional Practices | IEEE/ACM
- Managing and Leading Software Projects | Richard E. Fairley | CS
Press
- Metrics and Models in Software Quality Engineering, 2nd Edition
| Stephen H. Kan | Addison Wesley
- Numerical Mathematics and Computing, 6th Edition | E. Ward
Cheney and David R. Kincaid | Addison Wesley
- Operating System Concepts, 8th Edition | Abraham Silberschatz,
Peter Baer Galvin, and Greg Gagne | Wiley
- Professional Issues in Software Engineering | Frank Bott,
Allison Coleman, Jack Eaton, and Diane Rowland | Taylor and Francis
- Return on Software: Maximizing the Return on Your Software
Investment | Steve Tockey | Addison Wesley
- Security-Oriented Pointwise Changes to SWEBOK Guide | Samuel
Redwine
- Software Design, 2nd Edition | David Budgen | Addison Wesley
- Software Engineering, 8th Edition | Ian Sommerville | Addison
Wesley
- Software Inspection | Tom Gilb and D. Graham | Addison Wesley
- Software Maintenance: Concepts and Practice, 2nd Edition | Penny
Grubb and Armstrong A. Takang | World Scientific Publishing
- Software Security Engineering: A Guide for Project Managers |
Julia H. Allen, Sean Barnum, Robert J. Ellison, Gary McGraw, and
Nancy R. Mead | Addison Wesley
- The Essentials of Computer Organization and Architecture,
2nd Edition | Linda Null and Julia Lobur | Jones &
Bartlett
- The Road Map to Software Engineering: A Standards-Based Guide |
James W. Moore | CS Press
- Usability Engineering | Jakob Nielsen | Morgan Kaufmann
Hope you all the best,
Related Posts


| DOSE: |
2 hits |
oral |
LSD |
(blotter / tab) |
| |
repeated |
smoked |
Cannabis |
(plant material) |
[Erowid Note: Driving while intoxicated or tripping is dangerous and irresponsible because it endangers other people. Don't do it!]
I've dropped LSD a number of times, under a few different circumstances. From what I hear, the acid that I have always taken has been fairly mild. However, this 'mildness' means nothing to me, because it sure as hell does its job.
One day, me and six friends decided to get together on acid, smoke some weed, and hang out. My friend L's mom's house was empty and for sale, so we decided to take advantage of its vacancy and use it as a place to hang out while we tripped and smoked. Just above this house was L's grandparents' house, which also happened to be vacant and empty. So myself, L, J, K, G, T and C all met at L's mom's place one evening. We were all on acid, some more than others, (myself and T on the highest doses) and ready for fun.
We hung out at L's moms place for a while, taking a little journey onto the roof to look at the view, and smoking weed on the porch. My acid was just starting to kick in as we decided to move on up to L's grandparents' place. L didn't have a key to get inside his mom's, but there was one for his grandparents' house! It was getting dark by now. Two of us had cars, T and K. T moved his car up to the grandparents' driveway, and K left his at the mom's place.
Technically, none of us were supposed to be there. Not even L. His grandparents' didn't know he knew where the key was, and he didn't have permission to be inside.  K brought his guitar with him, so he could jam inside. A few of us gathered to the deck where we could continue to smoke some bowls. K and G were in the basement playing guitar, and I went to get them so they could come and get higher. On my way back up the stairs, I got the fright of my life.
L came charging at me, yelling that somebody was there! He took off down the stairs and I followed him, scared shitless. We turned out the lights and it was pitch black. Everyone made it into the basement, and for the next few minutes, there was complete confusion. Seven kids tripping on LSD were running around the dark basement of a house that didn't belong to any of them, and from what I heard, two cars had just pulled in the driveway!
All of a sudden, flashlights began to shine into the basement. We didn't know the house well, and remember, it's pitch black. All of us were dodging the flashlight, shitting our pants at the same time. The idea of the possibility of it being cops was in all of our heads I'm sure, but being on LSD wasn't really helping the situation much. L mentioned that it could be his grandpa shining the light in, (remember, the old man has the potential to do 'crazy shit'), and we were still all freaking out. We managed to gather into one of the empty bedrooms, all of us lining up against two of the walls. This was when the flashlights shined right on K and G, and the fact that we were busted was just kicking in.
 It was about this time when the doorbell rang, and L went up to confront whoever it was. A few moments later I could hear that it was a cop...oooh boy. A few of us had weed and at least one of us was still possessing acid. I had a joint in my wallet, which I stashed somewhere for a minute or two while L was still upstairs talking to the cop. The piggie sounded confused, I could hear him asking something about why there was a car down at the other house (L's mom's). L came downstairs, we were all aimlessly sitting or wandering around, and said it was time for us to go up.
I thought we were screwed.  We all went upstairs, and outside to face the consequences.   We all somehow managed to keep our composure though.
All seven of us were outside. Another cop car pulled up with two more piggies inside. L explained that we were there to listen to a couple of them play guitar, and that he didn't think anything was really wrong. He explained who owned both houses, and that they were vacant. Fortunately for all of us, the cops just asked a few questions, checked T's license, and took it for a misunderstanding.
 One false move or wrong answer to a question coulda been the end of us all, or at least some of us. Apparently, a neighbor called the cops when they saw us on the roof of L's momís house or something.
 But now we were leaving, and T had to drive on 2 hits! K also had to drive away from the situation. T spent some of the time driving with cops on all sides of him, but we sure as hell got away with it. I was riding shotgun at this points, fighting my bowels.
 I'll never forget that. None of us will. We were actually joking around with the cops in the end, making friends with them almost! Shit, if they only knew. As we drove around the rest of the night we saw a bunch more cops. One pig shot by us as though it was chasing someone (scary shit), we saw one parked in our school parking lot as we all drove right by it, and another one had pulled over a speeder. As we passed that cop, it looked to a few of us as though he was coming to get us, but that was probably the acid talking. It was a scary experience, but a memorable one. And we got away with it. Oh yes.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


--- layout: default title: Field Reference nav: fields ---
The fields listed here match up to the SAM data as defined in the public data extract available on SAM (go to the Data Access link on SAM to find more information).
We are working on improving access to the information on SAM. If you are directly integrating with SAM and need information about this or other interfaces into SAM, you can go to Interact, sign up, and then contact the your Change Control Board member to get access to the SAM Interfaces and Extracts Working Group forum.
| Field name | Description | Data type |
|---|


{% include "includes/header.html" %}
{% include "includes/logo.html" %} {% include "includes/social_box.html" %}
{% include "includes/navbar.html" %} {% block content %}
{% block body_content %} {{ this.body }} {% endblock body_content %}
{% endblock content %} {% include "includes/footer.html" %}


Point
class Point
represents a point in a 2d space
Summary
Properties from Point
| string |
|
| number |
|
| number |
|
Methods from Point
| Point |
|
| boolean |
|
| Point |
|
Public Properties
Public Methods
equals(x: number | Point | Vector2d, y: number) → {boolean}
return true if this point is equal to the given point
| Type | Description |
|---|---|
| boolean |
set(x: number, y: number) → {Point}
set the Point x and y properties to the given values
| Name | Type | Default | Description |
|---|---|---|---|
| x | number | 0 | |
| y | number | 0 |
| Type | Description |
|---|---|
| Point |
Reference to this object for method chaining |


Before Change
path["rewards"], self._inner_algo.discount).copy()
self._train_value_function(paths)
obs, actions, rewards, _, valids, baselines = self._inner_algo._process_samples( // pylint: disable=protected-access // noqa: E501
paths)
return _MAMLEpisodeBatch(paths, obs, actions, rewards, valids,
baselines)
After Change
self._train_value_function(paths)
obs = torch.Tensor(episodes.padded_observations)
actions = torch.Tensor(episodes.padded_actions)
rewards = torch.Tensor(episodes.padded_rewards)
valids = torch.Tensor(episodes.lengths).int()
with torch.no_grad():


--- title: Pruning Overview keywords: fastai sidebar: home_sidebar summary: "Make your neural network sparse with fastai" description: "Make your neural network sparse with fastai" nb_path: "nbs/01_pruning_overview.ipynb" ---
Matplotlib is building the font cache; this may take a moment.


Destruct this class.
After dispose has been called, this method returns true. Use this method to determine whether dispose() should be run again.
Start the looping animations on the current component
This is the id of the transition out timeline that you want to play
If the reset flag is set to true it will re-initialize the current timeline
This will stop the current looping animation, keep in mind it will not reset it just stop at the current state.
Calling transition in will trigger transitionIn on your transition controller and start the desired timeline.
Add this flag if you want to overwrite any active transitions
A promise that will be resolved when the transition in is completed
Calling transition out will trigger transitionOut on your transition controller and start the desired timeline.
Add this flag if you want to overwrite any active transitions
This is the id of the transition out timeline that you want to play
If the reset flag is set to true it will re-initialize the current timeline
A promise that will be resolved when the transition out is completed
Generated using TypeDoc
namespaced componentId


{% extends 'frame.html' %} {% load sleep_tags %} {% block content %}
Found {{count}} users.
No users found.
{% endif %} {% endif %} {% if requests %}The users below have asked you to friend them. They won't know if you friend them, hide the request, or leave it here.
Friends can see whatever you set friends to be able to see in your profile. Users you follow will show up here and in the creep page, for your convenience. They can't see that you follow them.
{% if friendfollow %}Add friends or follow other users above!
{% endif %} {% endblock %}


Note Taker
Write a note, save the content to a text file by clicking save. Clear to default string by pressing reset.
Save
Print
Reset


SUB POP ART DIRECTOR SASHA BARR NOMINATED FOR GRAMMY, ACCEPTS CLEAR IMPOSITION (AND HEARTY CONGRATULATIONS) FROM EMPLOYER
SUB POP ART DIRECTOR SASHA BARR NOMINATED FOR GRAMMY, ACCEPTS CLEAR IMPOSITION!
SUB POP ART DIRECTOR SASHA BARR NOMINATED FOR GRAMMY, ACCEPTS CLEAR IMPOSITION!
SUB POP ART DIRECTOR SASHA BARR NOMINATED FOR GRAMMY, ACCEPTS CLEAR IMPOSITION!
SUB POP ART DIRECTOR SASHA BARR NOMINATED FOR GRAMMY, ACCEPTS CLEAR IMPOSITION!
See more news
Arbor Labor Union
Beach House
Cullen Omori
Dwarves
Eugene Mirman
Father John Misty
Heron Oblivion
Lee Bains III
Low
Mass Gothic
METZ
Morgan Delt
Mudhoney
Arbor Labor Union
Beach House
Cullen Omori
Dwarves
Eugene Mirman
Father John Misty
Heron Oblivion
Lee Bains III
Low
Mass Gothic
METZ
Morgan Delt
Mudhoney
Sign up to receive daily news updates from Sub Pop. Updates will be sent out Monday through Friday at 10:00 am Pacific Time and will include the latest entries from the blog.


You deserve an affordable, professional and contemporary website for your business or personal needs.
I charge $xx per hour with a $xxx initial retainer. A typical website for a small business or for personal use will take about 4-6 hours to complete once I have everything I need from the client such as images, text content and the basic outline of functions. Most often, clients want me to host their site for them and keep it secure and maintained. This cost is an additional $xx per month. For further questions or to get your new website, contact me below.


Generic programming
Standard events and commands apply to a single specific resource.
Generic programming allows referencing a whole set of resources at once.
For example, you can specify:
- A single command to mute all products called BeoVision.
- An event specification that matches any button pressed that is called LightsON.
- An event that matches multi tap on any button in the kid’s bedroom
This has many benefits:
- A single macro can now substitute a lot of macros previously tailored for individual resources.
- The list of events and commands on a macro can be drastically reduced.
- More importantly, it encourages a consistent setup throughout the installation.
A few examples below illustrate the use of generic programming.
Note on name changes: Generic events and commands are matched against all possible resources every time an event occurs or a command is executed. So, if on a working configuration the installer changes the name of a resource, that resource may no longer match an existing generic event or command. So be consistent with naming of resources, and careful not to break functionality by renaming resources.
Example 1: Consistent lighting in all zones
It is extremely important for the user experience to be as consistent as possible throughout the whole installation, so that the user knows what to expect without having to memorize lots of different features or functions.
A typical example is wall keypads and lighting control.
Normally, you would try to set up all keypads in the home with, for example:
- The top key for turning the lights on to a default scene.
- The bottom key for turning the lights off.
This way, the user can walk into any room and have the lights on without remembering what each button does.
Other keys in the keypad may then be assigned for more specific functions, described by the key labels.
For this example, assume that the house has one or more lighting control systems, with keypads on all zones, and every zone either supports lighting scene selection, or direct control of a dimmer.
The following steps will get a consistent functionality for turning lights on with the topmost key in all keypads.
- Define resources for the top button of all keypads at room
entrances. Call them all by the same name
Lights ON
. - If a zone, such as a corridor, needs a second such button on
another keypad, call it
Lights ON 2
since you are not allowed to repeat names within a zone. - For zones with scene control, set up a scene for the default
lighting and assign a resource called
Scene ON
. - For zones with direct dimmer control, assign a resource for the
main lighting fixture and call it
Main dimmer
. - On the macro screen, add a new macro called
Generic lights ON
. Assign it to the special zone calledglobal
, since it applies to many zones. - Add a generic event that matches
any area
,any zone
,BUTTON
namedLights ON
, actionPRESS
. - Add more events if you used buttons named
Lights ON 2
. - Now add a generic command for
area that fired
,zone that fired
,BUTTON
namedScene ON
, actionPRESS
. - Add another command for
area that fired
,zone that fired
,DIMMER
namedMain dimmer
, actionSET LEVEL 85%
.
Notes:
- Events and commands that don’t match are silently ignored. For example, rooms with dimmer control won’t complain that there is no scene button available.
- The generic options
area that fired
andzone that fired
will only match the area and zone where the event was produced. In this case, you will only affect lighting on the same room where the key was pressed. - On the list of events and commands for the macro, you will see a
special encoded description. In the case of generic events and
commands, you will notice the use of
*
to mean any, and the codes$area
and$zone
as placeholders for the actual area and zone where the event occurred.
Example 2: All area off
The residence has 3 areas: Main house
, Pool
and Guest house
.
Pressing a button on Beo5/6 will switch off all lighting and A/V products in whole area.
Assume a button has been set up on Beo5 for this purpose, that sends
CONTROL 20
.
The installation is as follows:
- Video products in all zones are named
BeoVision
, and audio products are namedBeoSound
. - All zones have a lighting scene button called
OffScene
.
The macro is as follows.
Events:
CONTROL 20
on any video product (encoded as$area/$zone/AV Renderer/BeoVision/Control ? Action=Press & Command=FUNCTION_20
).CONTROL 20
on any audio prdouct (encoded as$area/$zone/AV Renderer/BeoSound/Control ? Action=Press & Command=FUNCTION_20
).
Commands:
- Set all video products in the same area, any zone, called “BeoVision” to standby
(encoded as
$area/*/AV Renderer/BeoVision/Standby
) - Set volume of all audio/video products in the same area, any zone, to standby
(encoded as
$area/*/AV Renderer/*/Volume level=30
) - Turn off all lighting by calling the OFF scene (encoded like
$area/*/BUTTON/OffScene/PRESS
)


@import models.ResponseModel.ResponseRecord @(responses: Option[List[ResponseRecord]]) @tr(s: String, s1: String, s2: String, s3: String) = {
| Home |
Surveys |
Questions |
Login |
Register |
| Survey Name | Question Name | Username | Answer |


{% extends 'article/list-base-guidance.html' %}
{% load static from staticfiles %}
{% block header_class %}business-planning{% endblock %}
{% block hero_title %}
Business
planning
{% endblock %}
{% block breadcrums_title %}
Business planning
{% endblock %}
{% block title %}
Plan to succeed
{% endblock %}
{% block subtitle %}
An export plan is your road map to exporting. It contains your reasons for exporting, routes to market and objectives.
{% endblock %}


Influencer Analysis
Generate ReportInfluencer Overview
Betweenness Centrality
Degree Centrality
Betweenness centrality
By calculating the betweenness centrality of the network of followers, we are able to visualize which are the key influencers and how important they are in sharing information to other followers. From the network graph generated, we can see that meimei_is_the_cutest has the highest betweenness centrality among other nodes.
Analysis
With a high betweenness centrality, it shows that this user is very important in connecting the followers in the network. Just to recap, it means that she has fallen on most of the shortest path between one follower to another and is critical in spreading information fast, between the followers in the network. On top of that, after looking at her instagram page, we found out that she is actually a food blogger, which makes her a perfect fit for FFL to engage for their next social media campaign.
https://www.instagram.com/meimei_is_the_cutest/
Degree Centrality
Degree centrality allow us to identify key influencers in the network that has the highest potential influencing power and sharing capability.
Analysis
From the network generated, we can see that melissackoh has the highest degree centrality in the network.This shows that melissackoh has the potential to reach many instagram users. In addition, melissackoh has around 264k influencers and is verified on instagram, hence this shows that she has high credibility and potential to reach many instagram users. So we will recommend FFL to engage melissackoh to be FFL promoter / influencer for the next social media marketing campaign.
https://www.instagram.com/melissackoh/
By calculating the betweenness centrality of the network of followers, we are able to visualize which are the key influencers and how important they are in sharing information to other followers. From the network graph generated, we can see that meimei_is_the_cutest has the highest betweenness centrality among other nodes.
Analysis
With a high betweenness centrality, it shows that this user is very important in connecting the followers in the network. Just to recap, it means that she has fallen on most of the shortest path between one follower to another and is critical in spreading information fast, between the followers in the network. On top of that, after looking at her instagram page, we found out that she is actually a food blogger, which makes her a perfect fit for FFL to engage for their next social media campaign.
https://www.instagram.com/meimei_is_the_cutest/
Degree Centrality
Degree centrality allow us to identify key influencers in the network that has the highest potential influencing power and sharing capability.
Analysis
From the network generated, we can see that melissackoh has the highest degree centrality in the network.This shows that melissackoh has the potential to reach many instagram users. In addition, melissackoh has around 264k influencers and is verified on instagram, hence this shows that she has high credibility and potential to reach many instagram users. So we will recommend FFL to engage melissackoh to be FFL promoter / influencer for the next social media marketing campaign.
https://www.instagram.com/melissackoh/


Issue: EVAL-WHEN-NON-TOP-LEVELForum: Compiler
References: EVAL-WHEN (CLtL pp69-70),
Issue DEFINING-MACROS-NON-TOP-LEVEL
Issue COMPILED-FUNCTION-REQUIREMENTS
Issue IN-PACKAGE-FUNCTIONALITY
Issue LOCALLY-TOP-LEVEL
Category: CLARIFICATION/CHANGE
Edit History: 06-May-88, Version 1 by Sandra Loosemore
16-Dec-88, Version 2 by Loosemore (alternate direction)
30-Dec-88, Version 3 by Loosemore (minor wording changes)
07-Jan-89, Version 4 by Loosemore (update discussion)
09-Feb-89, Version 5 by Pitman and Moon (some major changes)
09-Mar-89, Version 6 by Loosemore (clean up wording)
22-Mar-89, Version 7 by Loosemore (order of processing)
Status: Ready for release
Problem Description:
The current description of how the compiler should handle EVAL-WHEN
only makes sense when it appears as a top-level form in the file being
compiled. Is it legitimate for EVAL-WHEN to appear in non-top-level
locations? Even if it is legitimate, what does it mean?
Another issue, referred to here as ``the EVAL-WHEN shadowing problem,''
is that some people have complained that shadowing the symbols EVAL,
COMPILE, or LOAD means that you have to also either shadow EVAL-WHEN
and define it to recognize the new symbol, or else you must resign
yourself to writing (EVAL-WHEN (... LISP:EVAL ...) ...),etc. all over.
While the goal here is not to solve this problem, it might be possible
to solve both problems at once.
There are two proposals presented here, GENERALIZE-EVAL and
GENERALIZE-EVAL-NEW-KEYWORDS.
Background/Analysis:
The proposal which follows was constructed with the following goals
in mind:
1. The lexical and dynamic environment for the EVAL-WHEN body should
be the same for each situation. That is, the body should ``mean
the same thing'' regardless of which situation is being processed.
2. The evaluation context for EVAL-WHEN should be the current
lexical environment.
3. At execution time, EVAL-WHEN should always return the result of
its last form if execution of the body occurred, or NIL if the
body was not executed.
4. If a top-level EVAL-WHEN has a LOAD keyword, its body should
inherit top-level-ness during normal processing. This permits the
use of (EVAL-WHEN (EVAL COMPILE LOAD) ...) at top-level to mean
simply "Do whatever would normally be done for this body, but
also do something at compile time." This, in turn, will later be
the key to allowing defining forms to be usefully described in
terms of EVAL-WHEN.
5. Non-top-level expressions should have no effect until they are
executed. This is the key to making sure that any necessary
environment is present. Since the COMPILE keyword forces effects
to occur earlier than execution time, it follows from this that
any correct solution must not allow the COMPILE keyword to have
an effect at other than top-level.
To accomplish these goals, we formulated the following model:
The purpose of EVAL-WHEN is to accomodate the fact that some of the
semantic processing of an expression may usefully be partitioned
between compile time and run time in some circumstances.
describes a general technique for accomplishing some particular goal
at normal program execution time. However, the pair of expressions
(EVAL-WHEN (COMPILE) <code-A>)
can be used to describe an alternate technique for implementing part
of the effect (A) at compile-time, and part of the effect (B) at
load-time.
Proposal (EVAL-WHEN-NON-TOP-LEVEL:GENERALIZE-EVAL):
Replace the description of EVAL-WHEN with the following:
EVAL-WHEN ({situation}*) {form}* [Special Form]
The body of an EVAL-WHEN form is processed as an implicit PROGN, but
only in the situations listed. Each SITUATION must be a symbol,
either COMPILE, LOAD, or EVAL.
The use of COMPILE and LOAD controls whether and when processing
occurs for top-level forms. The use of EVAL controls whether
processing occurs for non-top-level forms.
The EVAL-WHEN construct may be more precisely understood in terms of
a model of how the file compiler, COMPILE-FILE, processes forms in a
file to be compiled.
Successive forms are read from the file by the file compiler using
READ. These top-level forms are normally processed in what we call
`not-compile-time' mode. There is one other mode, called
`compile-time-too' mode, which can come into play for top-level
forms. The EVAL-WHEN special form is used to annotate a program
in a way that allows the program doing the processing to select
the appropriate mode.
Processing of top-level forms in the file compiler works as follows:
* If the form is a macro call, it is expanded and the result is
processed as a top-level form in the same processing mode
(compile-time-too or not-compile-time).
* If the form is a PROGN form, each of its body forms is
sequentially processed as top-level forms in the same processing
mode.
* If the form is a COMPILER-LET, MACROLET, or SYMBOL-MACROLET,
the file compiler makes the appropriate bindings and recursively
processes the body forms as an implicit top-level PROGN with those
bindings in effect, in the same processing mode.
* If the form is an EVAL-WHEN form, it is handled according to
the following table:
COMPILE LOAD EVAL compile-time-too Action
Yes Yes -- -- Process body in compile-time-too mode
No Yes Yes Yes Process body in compile-time-too mode
No Yes Yes No Process body in not-compile-time mode
No Yes No -- Process body in not-compile-time mode
Yes No -- -- Evaluate body
No No Yes Yes Evaluate body
No No Yes No do nothing
No No No -- do nothing
"Process body" means to process the body as an implicit top-level
PROGN. "Evaluate body" means to evaluate the body forms as in
implicit PROGN in the dynamic execution context of the compiler and
in the lexical environment in which the EVAL-WHEN appears.
* Otherwise, the form is a top-level form that is not one of the
special cases. If in compile-time-too mode, the compiler first
evaluates the form and then performs normal compiler processing
on it. If in not-compile-time mode, only normal compiler
processing is performed. [The nature of this processing is
defined more precisely in issue COMPILED-FUNCTION-REQUIREMENTS.]
Any subforms are treated as non-top-level forms.
Note that top-level forms are guaranteed to be processed in the order
in which they textually appear in the file, and that each top-level
form read by the compiler is processed before the next is read.
However, the order of processing (including, in particular, macro
expansion) of subforms that are not top-level forms is unspecified.
For an EVAL-WHEN form that is not a top-level form in the file compiler
(that is, one of: in the interpreter; in COMPILE; or in the file
compiler but not at top-level), if the EVAL situation is specified,
its body is treated as an implicit PROGN. Otherwise, the EVAL-WHEN
form returns NIL.
Clarifications/Consequences:
The following effects are logical consequences of the above proposal:
* It is never the case that the execution of a single EVAL-WHEN
expression will execute the body code more than once.
* The keyword `EVAL' is a misnomer because execution of
the body need not be done by EVAL. In compiled code, such as
(DEFUN FOO () (EVAL-WHEN (EVAL) (PRINT 'FOO)))
the call to PRINT should be compiled.
* Macros intended for use in top-level forms should arrange for all
side-effects to be done by the forms in the macro expansion.
The macro-expander itself should not do the side-effects.
Wrong: (defmacro foo ()
(really-foo)
`(really-foo))
Right: (defmacro foo ()
`(eval-when (compile eval load) (really-foo)))
Adherence to this convention will mean that such macros will behave
intuitively when placed in non-top-level positions.
* Placing a variable binding around an EVAL-WHEN reliably captures the
binding because the `compile-time-too' mode cannot occur (because
introducing a variable binding would mean we were not at top level).
For example,
(LET ((X 3))
(EVAL-WHEN (EVAL LOAD COMPILE) (PRINT X)))
will print 3 at execution [load] time, and will not print anything at
compile time. This is important so that expansions of DEFUN and
DEFMACRO can be done in terms of EVAL-WHEN and can correctly capture
the lexical environment.
(DEFUN BAR (X) (DEFUN FOO () (+ X 3)))
might expand into
(DEFUN BAR (X)
(COMPILER::NOTICE-FUNCTION-DEFINITION 'FOO '(X)))
(SETF (SYMBOL-FUNCTION 'FOO) #'(LAMBDA () (+ X 3))))))
which would be treated the same as
(DEFUN BAR (X)
(SETF (SYMBOL-FUNCTION 'FOO) #'(LAMBDA () (+ X 3))))
by the above rules.
Test Cases:
;; #1: The EVAL-WHEN in this case is not at top-level, so only the EVAL
;; keyword is considered. At compile time, this has no effect.
;; At load time (if the LET is at top level), or at execution time
;; (if the LET is embedded in some other form which does not execute
;; until later) this sets (SYMBOL-FUNCTION 'FOO1) to a function which
;; returns 1.
(LET ((X 1))
(EVAL-WHEN (EVAL LOAD COMPILE)
(SETF (SYMBOL-FUNCTION 'FOO1) #'(LAMBDA () X))))
;; #2: If this expression occurs at the top-level of a file to be compiled,
;; it has BOTH a compile time AND a load-time effect of setting
;; (SYMBOL-FUNCTION 'FOO2) to a function which returns 2.
(EVAL-WHEN (EVAL LOAD COMPILE)
(LET ((X 2))
(EVAL-WHEN (EVAL LOAD COMPILE)
(SETF (SYMBOL-FUNCTION 'FOO2) #'(LAMBDA () X)))))
;; #3: If this expression occurs at the top-level of a file to be compiled,
;; it has BOTH a compile time AND a load-time effect of setting the
;; function cell of FOO3 to a function which returns 3.
(EVAL-WHEN (EVAL LOAD COMPILE)
(SETF (SYMBOL-FUNCTION 'FOO3) #'(LAMBDA () 3)))
;; #4: This always does nothing. It simply returns NIL.
(PRINT 'FOO4)))
;; #5: If this form occurs at top-level of a file to be compiled, FOO5 is
;; printed at compile time. If this form occurs in a non-top-level
;; position, nothing is printed at compile time. Regardless of context,
;; nothing is ever printed at load time or execution time.
(PRINT 'FOO5)))
;; #6: If this form occurs at top-level of a file to be compiled, FOO6 is
;; printed at compile time. If this form occurs in a non-top-level
;; position, nothing is printed at compile time. Regardless of context,
;; nothing is ever printed at load time or execution time.
(PRINT 'FOO6)))
Rationale:
This is compatible with any guarantees made by CLtL, and extends the
behavior usefully to non-top-level situations.
This gives a useful meaning to EVAL-WHEN that supports useful and
predictable behavior if defining macros are used in a non-top-level
situation.
The constraints on the order in which top-level forms are processed
ensure that the compile-time effects of defining macros and EVAL-WHENs
at the beginning of the file are visible during the processing of
forms that appear later in the file, which is what most users expect.
Leaving the order of processing of non-top-level forms unspecified
allows the compiler to perform certain kinds of transformations that
change the textual order of subforms. Users should not depend on
side-effects from macros that require them to be expanded in any
particular order.
Proposal (EVAL-WHEN-NON-TOP-LEVEL:GENERALIZE-EVAL-NEW-KEYWORDS):
As in GENERALIZE-EVAL, but rename the EVAL keyword to :EXECUTE,
the COMPILE keyword to :COMPILE-TOPLEVEL, and LOAD keyword to
:LOAD-TOPLEVEL.
Deprecate the use of keywords EVAL, COMPILE, and LOAD to EVAL-WHEN.
For compatibility, they are supported in EVAL-WHEN
at top-level, but their meaning is not defined elsewhere.
Rationale:
The fact that the situation keywords chosen are not the same as
those now used means that the change can be added in a way that
is truly upward compatible (not only with CLtL but with existing
practice in implementations which have chosen to extend or `clarify'
the definition given in CLtL) since the meaning of EVAL, COMPILE,
and LOAD in non-top-level situations (which was never spelled
out in CLtL) can legitimately differ from the meaning of these
new keywords.
Using other names and/or the keyword package for the names of
situations solves the EVAL-WHEN shadowing problem.
The name `execute' does not promote the confusion that the body of an
EVAL-WHEN must be executed only in the evaluator. It also does not
promote the confusion that the body of an EVAL-WHEN, regardless of when
executed, must run interpreted.
The names `compile-toplevel' and `load-toplevel' emphasize the fact
that these cases are not interesting in non-top-level positions.
Current Practice:
In Symbolics Genera, the interpreter permits EVAL-WHEN in non-top-level
positions in a way that is compatible with this proposal but both the
COMPILE and COMPILE-FILE functions complain about EVAL-WHEN in a
non-top-level position.
Both Lucid Common Lisp and Kyoto Common Lisp already interpret the
EVAL keyword to mean "execute" in non-top-level situations. Both of
these implementations also make (EVAL-WHEN (LOAD) ...) suppress
compile-time "magic" from defining macros such as DEFMACRO.
IIM describes its EVAL-WHEN as:
(defmacro eval-when (situations &body body &environment env)
(if (not (compiler-environment-p env))
(when (member 'eval situations) `(progn ,@body))
(when (member 'compile situations)
(if (compiler-at-top-level-p env)
(warn "Top-level form encountered at non-top-level.")))
(when (member 'load situations) `(progn ,@body)))))
Note that the interpretation of the EVAL situation and the nesting
behavior is different.
Cost to Implementors:
The actual change to EVAL-WHEN in both cases is probably fairly
localized and straightforward to make in most or all implementations.
The second-order costs of proposal GENERALIZE-EVAL will vary depending
on whether existing implementations have extended the definition of
EVAL-WHEN in incompatible ways. If an implementation has made such
extensions, there may be user and system code which depends on them
and the cost of converting that code may be non-trivial. There is
presumably also documentation impact.
Proposal GENERALIZE-EVAL-NEW-KEYWORDS avoids most or all of the
second-order costs of proposal GENERALIZE-EVAL.
The compiler processing for top-level forms might be implemented
something like:
;;; Forms read by the file compiler are passed to PROCESS-TOP-LEVEL-FORM
;;; with a env compile-time-too both NIL.
(defun process-top-level-form (form env compile-time-too)
(setq form (macroexpand form env))
nil)
(process-top-level-form f env compile-time-too)))
((eq (car form) 'compiler-let)
(process-compiler-let form env compile-time-too))
(process-macrolet form env compile-time-too))
((eq (car form) 'symbol-macrolet)
(process-symbol-macrolet form env compile-time-too))
(process-eval-when form env compile-time-too))
(t
(if compile-time-too
(internal-eval form env))
(compile-form form env))
))
(defun process-eval-when (form env compile-time-too)
(let* ((situations (cadr form))
(body (cddr form))
(compile-p (member 'compile situations))
(load-p (member 'load situations))
(eval-p (member 'eval situations)))
(cond ((or (and compile-p load-p)
(and eval-p load-p compile-time-too))
(process-top-level-form `(progn ,@body) env t))
(load-p
(process-top-level-form `(progn ,@body) env nil))
((or compile-p
(and eval-p compile-time-too))
(dolist (f body)
(internal-eval f env)))
(t
nil))))
;;; PROCESS-COMPILER-LET, PROCESS-MACROLET, and PROCESS-SYMBOL-MACROLET
;;; do the obvious things.
;;; INTERNAL-EVAL evaluates "form" in lexical environment "env".
Cost to Users:
Technically, none. Either proposal is technically upward compatible
with CLtL.
Proposal GENERALIZE-EVAL might force some extended implementations to
change incompatibly. As such, some users who depend on
implementation-dependent extensions might have to adjust their code
somewhat to deal with those changes.
Proposal GENERALIZE-EVAL-NEW-KEYWORDS does not force implementations
to change incompatibly, so has no forced impact on users.
Cost of Non-Adoption:
EVAL-WHEN is a mess. Using it as the low-level substrate into which
defining macros should expand, and guaranteeing any predictable effects
of those macros in non-top-level situations is currently difficult and
would continue to be so in the absence of some resolution on this issue.
Benefits:
The costs of non-adoption would be avoided: it would be possible to
use EVAL-WHEN in many situations where it cannot currently be used
reliably.
The portability of many existing tools which use EVAL-WHEN internally
in macros will be enhanced.
Aesthetics:
This generalization of the meaning makes the purpose and uses of
EVAL-WHEN less mysterious. In that sense, aesthetics are simplified
somewhat.
Discussion:
The cleanup issue LOCALLY-TOP-LEVEL would make LOCALLY also "pass
through" top-level-ness to its body. The reason why that is not
addressed in this issue is that it involves making LOCALLY a special
form.
Pitman and Moon don't care whether we say `top level,' `top-level,' or
`toplevel.' The spelling choices in this writeup are arbitrary. If
necessary, the proposal GENERALIZE-EVAL-NEW-KEYWORDS could be amended
to propose :COMPILE-TOP-LEVEL, etc.
Pitman, Moon, and Bob Laddaga (a Symbolics Cloe implementor) support
both of these proposals. Pitman and Laddaga have a preference for
GENERALIZE-EVAL-NEW-KEYWORDS. Moon is neutral about which should be
preferred.
Sandra Loosemore says:
I still feel somewhat uncomfortable with the definition of EVAL-WHEN
presented here, mostly because its nesting behavior is so unintuitive
(as in test case number 6). We have also had a hard time in deciding
what the term "top-level" really means; the definition presented here
is rather arbitrary. However, since we have run out of time in which
to come up with acceptable alternatives, I'm willing to go along with
proposal GENERALIZE-EVAL. It is compatible with the description in
CLtL but presented in a more coherent way, and I think it is an
improvement. On the other hand, I don't really like the idea of
changing the names of the keywords; if we are going to make an
incompatible change, the right thing to do would be to throw out
EVAL-WHEN entirely and start from scratch.
Treating MACROLET and SYMBOL-MACROLET (and possibly LOCALLY)
complicates the treatment of top-level DEFMACROs and other
defining macros that cause functions to be created at compile-time
(because the lexical environment the functions are defined in may
not be null). See issue DEFINING-MACROS-NON-TOP-LEVEL for details.-------


Begin by creating an accountand verifying your email address.
The most common option is to purchase a VPS (virtual private server) plan from a hosting company. In many cases you can run multiple Node.js apps for $2 - $10 per month on a VPS.
VPS hosting is very competitive and very cheap compared to cloud hosting. Examples of hosting companies are: Linode, Digital Ocean, Chicago VPS, and many more.Server Bear and LowEndBox are tools to help you compare VPS hosts. (Paastor is not affiliated with any of the services mentioned.)
The only officially supported server OS on Paastor (for now) isUbuntu 14.04.
Next, be sure to create a DNS "A" record with your DNS provider, and point to your server's IP address, for the domain you intend to serve.
Log in to Paastor and press the 'New Server' button from the Server Manager screen. Fill out all the fields. This will install the Sheep service on your server and allow you to push apps to the server.
From the Paastor UI, add an app to your server. You must add an app from the UI before pushing code.
Yourpackage.json
must have the following fields (these are example values):
{
// a single startup script
"main": "aStartupScript.js",
// list of domains for the Sheep proxy router
"domains": ["example.com", "www.example.com"],
"engines": {
// a single node version - no ranges
"node": "0.10.31"
}
}
pstr
command line tool$ npm install -g paastor
$ pstr login
Usepstr install-node [server] [version]
to add a version of Node to your server.
$ pstr install-node myserver1 0.10.28
Depending on the version, it may be installed quickly, or may need to compile from source.
Usepstr push [server] [app]
to push the app in the current directory to the specified server.
$ pstr push myserver1 someapp
push myserver1 someapp
Checking package.json
package.json exists
version ok 0.10.28
Domains look ok
Checking server...
Found myserver
Status ok
0.10.31 installed
Creating package from current directory...
Package created. 10.46mb
Prepping package for sending...
Package is ready to send.
Uploading and installing...
Ok
Stopping app...
Stopped.
Starting app...
Started
Cleaning up package...
Package cleaned.
Push complete.
$ pstr logs myserver1
$ pstr logs myserver1 someapp
All CLI commands can be seen by runningpstr --help
.
It's on the roadmap to release many parts of Paastor under an open source license.
Until then, refer to thedocumentation about the files Paastor puts on your server.


Rust and Python
Oxidize Your Snake
Sven-Hendrik Haase
svenstaro.org
This talk
- Motivation
- Current approaches
- Approach using Rust
- Takeaways
Motivation
- Speed up your program
- Escape the GIL (multithreading)
- Bind to existing system-libraries
Ways to speed up Python
Manual/C: Python C extensions, ctypes, cffi
Binding generator: Boost.Python, SWIG, PyO3
Specialized lib: pillow, numpy
JIT: pypy
Python-like dialect: cython
Problems of current approaches
Unsafe
C is not ergonomic
JIT unreliable
Multithreading
Instead, oxidize your snake
What is Rust?
- Safe
- Modern
- Fast
- Statically and strongly typed
- Immutable by default
- Private by default
- Amazing tooling
- Great community
- Cute mascot
- FEARLESS CONCURRENCY
What Rust looks like
Hello, Alice
Hello, Bob
Hello, Charlie
Hello, Alice
Hello, Bob
Hello, Charlie
Rust and Python
We'll use PyO3
Write Python modules in Rust
Use Python from Rust
Python module in Rust
$ python europython.py
Hello, Alisa 💖!
Structs as Python classes 1/2
Structs as Python classes 2/2
$ python classes.py
4
Let's calculate π using Monte Carlo
Some slow Python code
Very crappy way to estimate π.
$ time python slow.py
3.141624668
python slow.py 247.18s user 0.01s system 99% cpu 4:07.36 total
Some faster Rust code 1/2
Some faster Rust code 2/2
$ time python with_rust.py
3.141672068
python with_rust.py 4.95s user 0.00s system 99% cpu 4.966 total
We need to go even faster
Multithreading in Rust 1/2
Multithreading in Rust 2/2
$ time python multithreading.py
3.142886888
python multithreading.py 13.65s user 0.01s system 783% cpu 1.742 total
How to go faster from here?
- Use a better algorithm
- Use SIMD
- Cache optimizations
Pretty graphs
Python in Rust
$ Hello from Python 3.6.6 (default, Jun 27 2018, 13:11:40)
But why
Takeaways
- Rust can make your Python fast
- PyO3 makes integration easy


server module¶
-
server.
GetImage
()¶ Requests single image from database :param Input JSON: “username”: Username
“filename”: name of desired image
- Returns
- Dictionary with keys
File: filename Image: Image in b64 tiff format Process: processing algorithm applied
If user/image does not exist, an error message will be returned to the client.
- Return type
outjson
-
server.
NewImage
()¶ Post request for new image
- Parameters
json file (Input) –
"username" – username
"filename" – image file name
"rawimage" – image as base 64 string
"extension" – original file type
- Returns
- String verifying that image
has been saved
- Return type
outstr
-
server.
NewUser
()¶ Post request for new user
- Parameters
with input (JSON) –
"username" – Username
- Returns
- String verifying user has been saved
to database
- Return type
outstr
-
server.
bytes_to_plot
(bytes, extension)¶ Converts raw TIF format in Mongo to numpy array
- Parameters
bytes – image in byte
extension – file format (always tiff)
- Returns
numpy array version of image
- Return type
i
-
server.
convert_file
(I, extension)¶ Converts raw bytes of any format into any other format
- Parameters
I – byte format of image
extension – desired output file type
- Returns
byte format in desired file type
- Return type
data
-
server.
download_image
()¶ Returns a base 64 string of any file format requested by user
- Parameters
JSON (Input) – “username”: username “filename”: name of image in database “extension”: desired file type’
- Returns
- Dictionary with one entry
”Image”: image in base 64 string
- Return type
Outstring
-
server.
find_image
(filename, username)¶ Queries database for image :param Username: username :param filename: name of desired image
- Returns
- dictionary of image along with
all metadata
- Return type
image
-
server.
find_stats
(instr, List)¶ Finds number of times a specific algorithm has been used by a user
- Parameters
instr – Processing method
List – List of all images from a user
- Returns
- list with 2 elements:
- count: number of times algorithm
was used
latmean: average time to execute
- Return type
info
-
server.
get_histogram
()¶ Server request for image of histogram :param Input JSON: Username: username
Filename: filename
- Returns
base 64 string of histogram image
- Return type
outstring
-
server.
get_image_list
()¶ A route to GET a list of processed image name from MongoDB :param Input json keys: “username”
- Returns
list of all images the user has stored
- Return type
outjson
-
server.
get_metrics
(username)¶ Searches database for relevant user metrics :param Username: username
- Returns
- List of all algorithms with
times used and mean time to execute
- Return type
Outdict
-
server.
get_process
()¶ Processes image and saves to database
- Parameters
json (Input) –
"username" – username
"filename" – name of image to be processed
"process" – Desired processing algorithm
- Returns
Confirmation that image was processed
- Return type
outjson
-
server.
get_process_image_list
(username)¶ Get the list of names of processed image :param JSON input: “username”
- Returns
- Names of all files that have been
processed by the user
- Return type
pro_filenames (list)
-
server.
image_metrics
()¶ Obtain metrics for a certain image
- Parameters
json (Input) – “username”: username “filename”: name of image
- Returns
- List of all algorithms with
number of times used and time to execute
- Return type
outdict
-
server.
plot_to_bytes
(plot)¶ Converts numpy array into raw TIF format for MongoModel
- Parameters
plot – numpy array version of image
- Returns
image in bytes
- Return type
data
-
server.
process_image
(iraw, process)¶ Processes image as specified by user
- Parameters
iraw – Image to be processed
process – processing method
- Returns
- list with 2 entries: processed image
and time to process image
- Return type
i_process
-
server.
read_data_as_b64
(I_bytes)¶ Used for converting input data into base64
- Parameters
I_bytes – image in uint8 bytes
- Returns
image output string in base 64
- Return type
b64_string
-
server.
save_b64_image
(base64_string)¶ Saves base64 string as bytes
- Parameters
base64_string – image output string in base 64
- Returns
image in bytes
- Return type
image_bytes
-
server.
save_image
(user, filename, image_tif, process, latency, size, hist)¶ Function that saves image to Mongo database
- Parameters
user – username
filename – desired file name in database
image_tif – tiff image in byte format
process – processing algorithm applied to image
latency – time to process image
size – image size
hist – histogram values of image
bins – bin locations of image
- Returns
Confirmation that image has been saved
- Return type
outstr
-
server.
user_metrics
()¶ Return metrics for given user :param Input json: “username:: username
- Returns
dictionary of all image processing algorithms, times used, and time to execute
- Return type
outjson
-
server.
verify_newimage
(filename, files)¶ Checks existence of filename
- Parameters
filename – Image name
ID – Username
- Returns
Boolean value. If x is true, image does not exist in database
- Return type
x
-
server.
verify_newuser
(users, ID)¶ Checks existence of username
- Parameters
ID – Username
- Returns
Boolean value. If x = True, user does not exist in database
- Return type
x


Header
Description of a single Header item that the user can select.
Properties
Link copied to clipboard
Optional text to show as the title in the bread crumb.
Link copied to clipboard
Resource ID of optional text to show as the title in the bread crumb.
Link copied to clipboard
Optional arguments to supply to the fragment when it is instantiated.
Link copied to clipboard
Optional summary describing what this header controls.
Link copied to clipboard
Resource ID of optional summary describing what this header controls.
Link copied to clipboard
Title of the header that is shown to the user.


--- ---
The return value of a TransitionHookFn or TransitionStateHookFn
When returned from a TransitionHookFn or TransitionStateHookFn, these values alter the running Transition:
false
: the transition will be cancelled.Promise
: the transition will wait for the promise to resolve or rejectfalse
), the transition will be cancelledA predicate type which tests if a StateObject and Transition passes some test. Returns a boolean.
Generated using TypeDoc
Hook Criterion used to match a transition.
A Glob string that matches the name of a state.
Or, a function with the signature
function(state, transition) { return matches; }
which should return a boolean to indicate if a state matches.Or,
true
to always match


Page 1 of 2
An idea for the world structure.
Posted:
Tue Jul 17, 2007 1:45 pm
by Vitriol
Right now what we have the players spawning into is essentially a round island with 3 villages, a road, and a forest. I think this is a good idea. New players should spawn on the "newbie island" where they learn how to play and get their first few levels. I was thinking that after a player gets level 5 he would get to travel though a harder dungeon with skeletons and maybe a volucris as the boss and the end would take him to the main big world that we have yet to craft. This is essentially a rip off from the first lineage: the blood pledge game. Gimmie some feedback.
Posted:
Tue Jul 17, 2007 1:48 pm
by thadiusofx3
great idea!
The dungeon could sorta be like the great hall with waves of progressively harder enemies so you would possibly have to group up to complete it, and a final harder boss. (nice touch with the volucris there)
At the end could be a port mark or a static portal(I like the idea of this) to the main world.
Posted:
Tue Jul 17, 2007 2:09 pm
by Vitriol
yeah, i was thinking at the end of the dungeon would be a portal that just never closes. (I am not a fan of port "squares")
The mini-great hall idea is great. You could start with some aggressive giant bugs, then imps (if we keep those), the rogues, then trolls, some barbarians and thieves, followed by some skeletons, and then a volucris.
Posted:
Tue Jul 17, 2007 2:10 pm
by Vitriol
The great thing is that in the main, big map we wouldnt need to place newbie enemies. You could have rogues/trolls as the weakest enemies kinda uniformly spread around the map, without worrying about giant bug/imp spawns.
Posted:
Tue Jul 17, 2007 4:29 pm
by 9sam1
i wouldnt like this at all.
Posted:
Tue Jul 17, 2007 4:45 pm
by thadiusofx3
What's your reasoning behind that?
Posted:
Tue Jul 17, 2007 6:50 pm
by speed3b
Great idea. I like the idea of having to group together to make it though too. And if you dont meet the level requirement, it wont let you in the dungeon or even out of the world. Which also kind of leads on to another thing. Would you beable to return to this other world in the future? Part of me says yes, and part of me says no. I wouldnt want people going there and pking newbs all the time.
Posted:
Tue Jul 17, 2007 6:50 pm
by a_link_to_the_past
Hmm.. reminds me of runescape to a degree (yes I have played runescape... when you are bored you will play anything) The newb Island I think is a good idea... instead of being thrown into the land knowing absolutely nothing and walking off into the woods and getting bum raped by some random troll...
Posted:
Tue Jul 17, 2007 6:52 pm
by Karl G.
I think a noob island is a wonderful idea; and no, it shouldn't be accessible to higher levels.
Posted:
Tue Jul 17, 2007 7:13 pm
by Ratiotile
It's a great idea for newbies, however once you have played a high level and want to make new characters it would be tedious to go through the newbie dungeon every time, wouldn't it? The noob dungeon reminds me of Fallout 2, where new character had to finish a dungeon before going to the real world. I must have created 10 new characters and that was my least favorite part of the game. Make it optional?
Posted:
Tue Jul 17, 2007 7:32 pm
by a_link_to_the_past
hmmm that is a very good point... perhaps you could have a basic game intro... like where a guard of some sort speaks to you... teaches you about how things work in the world... gives you a little area to fight bugs and imps to give you a first hand experience of how it works... and then gives you an option to "would you like to stay and train, or would you like to continue to the mainland" It would give those people new to the game the opportunity to learn about it and give those firmilar to it a way out... you could decline the intro speech just the same as the bug task in xenimus now..
Posted:
Tue Jul 17, 2007 7:56 pm
by 9sam1
thadiusofx3 wrote:What's your reasoning behind that?
I wanna be able to make a noob, and go straight to interacting with high lvls, weather it be to transfer or jsut meet a friend. I dont wanna be forced to lvl to 5 on some noob island every time i make a noob.
Posted:
Tue Jul 17, 2007 8:05 pm
by thadiusofx3
ok how about a checkbox when you create a character to spawn on the newbie island or directly to the main continent
not everyone wants to interact with the high levels right off the bat
Posted:
Tue Jul 17, 2007 8:12 pm
by thadiusofx3
Actually what about if you have a character over level 5 you can skip the newbie continent.
Posted:
Tue Jul 17, 2007 11:24 pm
by ziggman
this is something that could work GREAT with new subclassing!!
when noobs reach level 10 or so, they have to compelete an initiation quest to lock in thier finnal class. (kill the volucris & go into port)at the end they would have to decide what class they become. then they would get ported to thier new 'home' town based on what class they chose.
these class towns should be very small but should have Many quests specialized for your class/level.
fighter town
(barbs/fighters)
Holy town
(clerics/pallys)
wizard town
(druids/wizards)
warlock town
(darkwar/warlock)
Thief town
(rangers/theives)
of course you would have one major city. every 'class town' should have a port merchant that ports to the central main town.
*on a different note i think thieves and rangers should be 2 different classes. thieves should be able to duel wield with 2 daggers or 2 short swords , or one short sword one regular sword. and rangers should primairly use bows.
Posted:
Wed Jul 18, 2007 1:13 pm
by Vitriol
thadiusofx3 wrote:Actually what about if you have a character over level 5 you can skip the newbie continent.
The idea is to provide a smooth introduction for people new to the game, so that idea is fine.
Posted:
Mon Jul 23, 2007 12:44 am
by JSunJShineR
Hey guys, you know that waterfall looking thing in evil-side Solus castle where the mystic merch is? the purple thing. Why not have Main portals to different towns or where ever look like this? a sold port that doesnt go away. and certain places require a lvl. also a sign that you can right click next to the portal teeling where it is to so we know where to go. and temporary ports will be a simpler version of this.
personalyl
Posted:
Wed Jul 25, 2007 4:03 am
by Richard. UK
Personally i do not liek the idea for a "class town" as the game will not be hosting masses of people to begin with, therfore if people join and go to a "class town" this limits the amount of actual players that play the game they will see, untill they reach levels high enuf to go to main towns.
I really like the idea of a Newbie get to know our game island. and when you leave you are transported to a town like Aridus, i think the game should be based around Aridus in the outside world just because it is the most xenimus related town that everyone knows and enjoys or did.
thats only my thoughts tho
Posted:
Wed Jul 25, 2007 6:31 am
by Karl G.
I thought we agreed there would be only 1 town at the start...
Posted:
Wed Jul 25, 2007 8:53 am
by thadiusofx3
remember we had that small continent that was in the upper right hand corner and i divided it up into sections with 3 town?
Posted:
Wed Jul 25, 2007 10:59 pm
by Vitriol
thadiusofx3 wrote:remember we had that small continent that was in the upper right hand corner and i divided it up into sections with 3 town?
I remember this, but we might as well just have one small newbie town and wilderness, a graveyard, a cave or 2 surrounding it. With the exit temple located far away from the town.
It doesnt really matter, but I do prefer the idea of concentrating the playerbase in one popular town. It used to be semel, then it was terthius for a while, then eventually everyone just hung out in aridus, which is what people still do.
Posted:
Thu Jul 26, 2007 1:59 am
by ziggman
i think people chose airdus because free ports to 2 other towns, and its very open for pvp.
i would be good with one small newbie island with a town for now, im so bored since i quit xen, no other game feeds my addiction... yet.
Posted:
Thu Jul 26, 2007 5:16 am
by Vitriol
ziggman wrote:i think people chose airdus because free ports to 2 other towns, and its very open for pvp.
i would be good with one small newbie island with a town for now, im so bored since i quit xen, no other game feeds my addiction... yet.
And I dont think we will be bringing that back. It was always a dumb idea. Players should be hanging out at the capital, the most important city.
The way to do this is to provide merchants which sell items you cant get in other towns. that way one city will become the default city. but we are quite far from this, as for now players will be spawning on the newbie island, with no way off lol.
Posted:
Wed Aug 08, 2007 9:43 pm
by Volcomboy99
i liked the idea for a newbie island but i started thinking
the newbie island will only popular when the game first releases and everyone is just starting to play, after everyone has there high lvls they will just skip the newbie island if they have a choice
the brand new players would be alone alote and they might think that the game is empty and boring and leave before knowing about all of the people in the other world
and if they are alone they would not be able to complete the dungeon and make it into the next world
Posted:
Thu Aug 09, 2007 11:11 am
by 9sam1
Vitriol wrote:ziggman wrote:i think people chose airdus because free ports to 2 other towns, and its very open for pvp.
i would be good with one small newbie island with a town for now, im so bored since i quit xen, no other game feeds my addiction... yet.
And I dont think we will be bringing that back. It was always a dumb idea. Players should be hanging out at the capital, the most important city.
The way to do this is to provide merchants which sell items you cant get in other towns. that way one city will become the default city. but we are quite far from this, as for now players will be spawning on the newbie island, with no way off lol.
why does vitriol always speak like he is the creator of this game.
and btw if theres a noob island like that, i will stop supporting this game 100%


For Mplus (Muthén and Muthén 2017) to work properly, make sure that you save the input file with the model specification (example.inp) in the same folder as the data (example.dat). You can download the simulated example datasets here. Mplus includes defaults, like that:
These defaults are included to make the specification of many standard SEM models easier, but they are not always useful in the current modeling context. Therefore, we use the command ANALYSIS: MODEL = NOCOV;
to overrule these defaults for the covariances and set all of them to zero.
To specify the RI-CLPM we need four parts.
BY
command, RIx BY x1@1 x2@1 ...;
, where @1
fixes the factor loading to one.BY
command, wx1 BY x1; wx2 BY x2; ...
. We do not have to constrain the factor loading to 1, as this is already the default in Mplus for the factor loading of the first indicator of a latent variable. However, we do need to constrain the measurement error variances to zero, as Mplus will include them by default when we use the BY
statement. We do this by including x1@0 x2@0 x3@0 x4@0 x5@0;
where @0
fixes the measurement error variances to zero, which is the same as saying there is no measurement error.wx2 ON wx1 wy1; wx3 ON wx2 wy2; ...
.wx1 WITH wy1; wx2 WITH wy2;...
. For the between part we have to specify that the random intercepts are correlated using RIx WITH RIy;
.The syntax for specifying the basic RI-CLPM is given below.
TITLE: The basic RI-CLPM, 5 waves.
DATA: FILE = RICLPM.dat;
VARIABLE: NAMES = x1-x5 y1-y5;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create between components (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
!  Constrain the measurement error variances to zero
x1-y5@0;
!  Estimate the covariance between the random intercepts
RIx WITH RIy;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations)
wx2 WITH wy2;
wx3 WITH wy3;
wx4 WITH wy4;
wx5 WITH wy5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Imposing constraints to the model can be achieved by giving labels to parameters and using the same label for parameters that you want to constrain to be equal. A label is specified by adding (label)
after a parameter. Below we specify a RI-CLPM with the following constraints:
(a b c d)
,(cov)
, (vx)
, and (vy)
, and(mx)
and (my)
.TITLE: The basic RI-CLPM, 5 waves.
Constrain the grand means, (residual) variances, and
lagged effects over time.
DATA: FILE = RICLPM.dat;
VARIABLE: NAMES = x1-x5 y1-y5;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create between components (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
!  Constrain the measurement error variances to zero
x1-y5@0;
! Estimate the lagged effects between
! the within-person centered variables
wx2 wy2 ON wx1 wy1 (a b c d);
wx3 wy3 ON wx2 wy2 (a b c d);
wx4 wy4 ON wx3 wy3 (a b c d);
wx5 wy5 ON wx4 wy4 (a b c d);
! Estimate the covariance between the random intercepts
RIx WITH RIy;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations) and
! constrain these and the residual variances to be
! invariant over time
wx2 WITH wy2 (cov); wx2 (vx); wy2 (vy);
wx3 WITH wy3 (cov); wx3 (vx); wy3 (vy);
wx4 WITH wy4 (cov); wx4 (vx); wy4 (vy);
wx5 WITH wy5 (cov); wx5 (vx); wy5 (vy);
! Constrain grand means to be invariant over time
[x1 x2 x3 x4 x5] (mx);
[y1 y2 y3 y4 y5] (my);
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Use the tabs below to navigate to the model specification of the RI-CLPM with
Below you can find the syntax for a RI-CLPM with 5 waves and a time-invariant predictor \(z_{1}\) for the observed variables. The effect of \(z_{1}\) on the observed variables is constrained to be the same across waves.
TITLE: RI-CLPM, 5 waves, including a time-invariant predictor for
the observed variables.
DATA: FILE = RICLPM-Z.dat;
VARIABLE: NAMES = x1-x5 y1-y5 z2 z1;
USEVARIABLES = x1-y5 z1;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create between components (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
! Estimate the covariance between the random intercepts
RIx WITH RIy;
!  Constrain the measurement error variances to zero
x1-y5@0;
! Regression of observed variables on z1 (unconstrained)
x1-x5 ON z1 (s1);
y1-y5 ON z1 (s2);
! Estimate the lagged effects between the within-person
! centered variables
wx2 wy2 ON wx1 wy1;
wx3 wy3 ON wx2 wy2;
wx4 wy4 ON wx3 wy3;
wx5 wy5 ON wx4 wy4;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations)
wx2 WITH wy2;
wx3 WITH wy3;
wx4 WITH wy4;
wx5 WITH wy5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Below you can find the syntax for a RI-CLPM with 5 waves and a time-invariant predictor \(z_{1}\) for the random intercepts.
TITLE: RI-CLPM, 5 waves, including a time-invariant predictor for
the random intercepts.
DATA: FILE = RICLPM-Z.dat;
VARIABLE: NAMES = x1-x5 y1-y5 z2 z1;
USEVARIABLES = x1-y5 z1;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create between components (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
! Estimate the covariance between the random intercepts
RIx WITH RIy;
!  Constrain the measurement error variances to zero
x1-y5@0;
! Regression of random intercepts on z1
RIx RIy ON z1;
! Estimate the lagged effects between the within-person
! centered variables
wx2 wy2 ON wx1 wy1;
wx3 wy3 ON wx2 wy2;
wx4 wy4 ON wx3 wy3;
wx5 wy5 ON wx4 wy4;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations)
wx2 WITH wy2;
wx3 WITH wy3;
wx4 WITH wy4;
wx5 WITH wy5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Below you can find the syntax for a RI-CLPM with 5 waves and the random intercepts predicting the time-invariant outcome \(z_{2}\).
TITLE: RI-CLPM, 5 waves.
Time-invariant predictor z1 for observed variables (constrained).
Between components predicting time-invariant outcome z2.
DATA: FILE = RICLPM-Z.dat;
VARIABLE: NAMES = x1-x5 y1-y5 z2 z1;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create between components (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
! Estimate the covariance between the random intercepts
RIx WITH RIy;
! Regres distal outcome on random intercepts
z2 ON RIx RIy;
!  Constrain the measurement error variances to zero
x1-y5@0;
! Regression of observed variables on z1 (constrained)
x1-x5 ON z1 (s1);
y1-y5 ON z1 (s2);
! Estimate the lagged effects between the within-person
! centered variables
wx2 wy2 ON wx1 wy1;
wx3 wy3 ON wx2 wy2;
wx4 wy4 ON wx3 wy3;
wx5 wy5 ON wx4 wy4;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations)
wx2 WITH wy2;
wx3 WITH wy3;
wx4 WITH wy4;
wx5 WITH wy5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Below you can find the syntax for a RI-CLPM with 5 waves and the within components predicting the time-invariant outcome \(z_{2}\).
TITLE: RI-CLPM, 5 waves
Time-invariant predictor z1 for observed variables (constrained).
Within components predicting time-invariant outcome z2.
DATA: FILE = RICLPM-Z.dat;
VARIABLE: NAMES = x1-x5 y1-y5 z2 z1;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create two individual factors (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
! Estimate the covariance between the random intercepts
RIx WITH RIy;
!  Constrain the measurement error variances to zero
x1-y5@0;
! Regres distal outcome on within components
z2 ON wx1-wx5 wy1-wy5;
! Regression of observed variables on z1 (constrained)
x1-x5 ON z1 (s1);
y1-y5 ON z1 (s2);
! Estimate the lagged effects between the within-person
! centered variables
wx2 wy2 ON wx1 wy1;
wx3 wy3 ON wx2 wy2;
wx4 wy4 ON wx3 wy3;
wx5 wy5 ON wx4 wy4;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations)
wx2 WITH wy2;
wx3 WITH wy3;
wx4 WITH wy4;
wx5 WITH wy5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Use the tabs below to navigate to the model specification of the basic multiple-group model, or the model with constrained lagged parameters (and intercepts across groups).
To specify a multiple group RI-CLPM, we need to overrule some of the defaults that Mplus will impose and that are associated with multiple group factor analysis. The reason for this is that when we use the BY
statement in combination with multiple groups, Mplus will automatically impose the defaults that are associated with strong factorial invariance (Meredith (1993)). These defaults are:
In the context of a multiple-group RI-CLPM, the first constraint is not an issue as all the factor loadings are supposed to be constrained to one in both groups. However, the second constraint on the intercepts and the freeing of the latent means in the second group are not sensible here. There will be fewer observed variables than latent variables defined with a BY
statement (i.e., a within-unit part for each observed variable, plus a random intercept for each variable); as a result, we would try to estimate more means than that there were observed. Such a model is unidentified. We should therefore overrule the defaults associated with the mean structure. We do this by adding for the second group [x1 x2 ...];
which frees the intercepts for the observed variables in the second group. Additionally, we include [wx1@0 wx2@0 ... ]; [RIx@0];
for the second group, which ensures all latent means are fixed to zero.
Below you can find the code for a multiple group RI-CLPM with 5 waves.
TITLE: Multiple group RI-CLPM, 5 waves.
Overruling the Mplus multiple group factor analysis defaults.
DATA: FILE = RICLPM-MG.dat;
VARIABLE: NAMES = x1-x5 y1-y5 GROUP;
GROUPING = GROUP (1=G1 2=G2);
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create between components (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
!  Constrain the measurement error variances to zero
x1-y5@0;
! Estimate the lagged effects between the within-person
! centered variables
wx2 wy2 ON wx1 wy1;
wx3 wy3 ON wx2 wy2;
wx4 wy4 ON wx3 wy3;
wx5 wy5 ON wx4 wy4;
! Estimate the covariance between the random intercepts
RIx WITH RIy;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations)
wx2 WITH wy2;
wx3 WITH wy3;
wx4 WITH wy4;
wx5 WITH wy5;
MODEL G2: ! Overrule the multiple group factor analysis default
! of equal intercepts across the groups
[x1-y5];
! Overrule the multiple group factor analysis default
! of free latent means in the second group
[wx1-wy5@0];
[RIx@0 RIy@0];
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Below you can find the code for a multiple group RI-CLPM, 5 waves. The lagged-parameters are constrained to be equal over time.
TITLE: Multiple group RI-CLPM, 5 waves, with equal lagged parameters
across groups.
Overruling the Mplus multiple group factor analysis defaults.
DATA: FILE = RICLPM-MG.dat;
VARIABLE: NAMES = x1-x5 y1-y5 GROUP;
GROUPING = GROUP (1=G1 2=G2);
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: ! Create between components (random intercepts)
RIx BY x1@1 x2@1 x3@1 x4@1 x5@1;
RIy BY y1@1 y2@1 y3@1 y4@1 y5@1;
!  Constrain the measurement error variances to zero
x1-y5@0;
!  Estimate the covariance between the random intercepts
RIx WITH RIy;
! Estimate the covariance between the within-person
! components at the first wave
wx1 WITH wy1;
! Estimate the covariances between the residuals of
! the within-person components (the innovations)
wx2 WITH wy2;
wx3 WITH wy3;
wx4 WITH wy4;
wx5 WITH wy5;
MODEL G2: ! Overrule the multiple group factor analysis default
! of equal intercepts across the groups
[x1-y5];
! Overrule the multiple group factor analysis default
! of free latent means in the second group
[wx1-wy5@0];
[RIx@0 RIy@0];
! Estimate the lagged effects between the within-person
! centered variables (constrained across groups)
wx2 wy2 ON wx1 wy1 (a1 b1 c1 d1);
wx3 wy3 ON wx2 wy2 (a2 b2 c2 d2);
wx4 wy4 ON wx3 wy3 (a3 b3 c3 d3);
wx5 wy5 ON wx4 wy4 (a4 b4 c4 d4);
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
Use the tabs below to navigate to the model specification of a multiple indicator RI-CLPM, 5 waves and 3 indicators for each variable at each wave. The five steps correspond to:
When we have three indicators \(X\), measured at five waves, we specify three random intercepts to capture the trait-like part of each indicator, that is, RIX1 BY x11@1 x21@1 ...;
, RIX2 BY x12@1 x22@1 ...;
, and RIX3 BY x13@1 x23@1 ...;
. In addition, we specify five within-unit components that capture the state-like part at each wave, using WFX1 BY x11 x12 x13; WFX2 BY x21 x22 x23; ...
.
At the latent within-unit level, we specify the dynamic model in Mplus usingWFX2 ON WFY1 WFX1; WFX3 ON WFY2 WFX2; ...
. In addition, we allow the within-person factors at the first wave, and their residuals at subsequent waves to be correlated within each wave, WFX1 WITH WFY1; WFX2 WITH WFY2; ...
. The six random intercepts are allowed to be freely correlated with each other through RIX1-RIY3 WITH RIX1-RIY3;
.
TITLE: Multiple indicator RI-CLPM, 5 waves, with 3 indicators for
each variable at each wave (30 observed variables) and with
random intercepts for each indicator separately.
DATA: FILE = RICLPM-MI.dat;
VARIABLE: NAMES = x11 x12 x13 x21 x22 x23 x31 x32 x33
x41 x42 x43 x51 x52 x53 y11 y12 y13
y21 y22 y23 y31 y32 y33 y41 y42 y43
y51 y52 y53;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL:
!!!!!!!!!!!!!!!!
! BETWEEN PART !
!!!!!!!!!!!!!!!!
! Create between factors (random intercepts) for each indicator separately
RIX1 BY x11@1 x21@1 x31@1 x41@1 x51@1;
RIX2 BY x12@1 x22@1 x32@1 x42@1 x52@1;
RIX3 BY x13@1 x23@1 x33@1 x43@1 x53@1;
RIY1 BY y11@1 y21@1 y31@1 y41@1 y51@1;
RIY2 BY y12@1 y22@1 y32@1 y42@1 y52@1;
RIY3 BY y13@1 y23@1 y33@1 y43@1 y53@1;
! Add covariances between all RIs
RIX1-RIY3 WITH RIX1-RIY3;
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: MEASUREMENT MODEL !
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! Due to having a random intercept per indicator, the measurement model
! here is only on the within part of the measurements
! Factor models for x at 5 waves
WFX1 BY x11-x13;
WFX2 BY x21-x23;
WFX3 BY x31-x33;
WFX4 BY x41-x43;
WFX5 BY x51-x53;
! Factor models for y at 5 waves
WFY1 BY y11-y13;
WFY2 BY y21-y23;
WFY3 BY y31-y33;
WFY4 BY y41-y43;
WFY5 BY y51-y53;
!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: DYNAMICS !
!!!!!!!!!!!!!!!!!!!!!!!!!
!  Estimate the correlations within the same wave
WFX1 WITH WFY1;
WFX2 WITH WFY2;
WFX3 WITH WFY3;
WFX4 WITH WFY4;
WFX5 WITH WFY5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
In second step, we constrain the factor loadings to be invariant over time using the labels (a b c)
and (d e f)
.
TITLE: Multiple indicator RI-CLPM, 5 waves, with 3 indicators for
each variable at each wave (30 observed variables) and with
random intercepts for each indicator separately. Fitting a model
with constraints to ensure weak factorial invariance.
DATA: FILE = RICLPM-MI.dat;
VARIABLE: NAMES = x11 x12 x13 x21 x22 x23 x31 x32 x33
x41 x42 x43 x51 x52 x53 y11 y12 y13
y21 y22 y23 y31 y32 y33 y41 y42 y43
y51 y52 y53;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: !!!!!!!!!!!!!!!!
! BETWEEN PART !
!!!!!!!!!!!!!!!!
! Create between factors (random intercepts) for each indicator separately
RIX1 BY x11@1 x21@1 x31@1 x41@1 x51@1;
RIX2 BY x12@1 x22@1 x32@1 x42@1 x52@1;
RIX3 BY x13@1 x23@1 x33@1 x43@1 x53@1;
RIY1 BY y11@1 y21@1 y31@1 y41@1 y51@1;
RIY2 BY y12@1 y22@1 y32@1 y42@1 y52@1;
RIY3 BY y13@1 y23@1 y33@1 y43@1 y53@1;
! Add covariances between all RIs
RIX1-RIY3 WITH RIX1-RIY3;
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: MEASUREMENT MODEL !
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! Due to having a random intercept per indicator, the measurement model
! here is only on the within part of the measurements
! Factor models for x at 5 waves
WFX1 BY x11-x13 (a b c);
WFX2 BY x21-x23 (a b c);
WFX3 BY x31-x33 (a b c);
WFX4 BY x41-x43 (a b c);
WFX5 BY x51-x53 (a b c);
! Factor models for y at 5 waves
WFY1 BY y11-y13 (d e f);
WFY2 BY y21-y23 (d e f);
WFY3 BY y31-y33 (d e f);
WFY4 BY y41-y43 (d e f);
WFY5 BY y51-y53 (d e f);
!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: DYNAMICS !
!!!!!!!!!!!!!!!!!!!!!!!!!
!  Estimate the correlations within the same wave
WFX1 WITH WFY1;
WFX2 WITH WFY2;
WFX3 WITH WFY3;
WFX4 WITH WFY4;
WFX5 WITH WFY5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
In Mplus, the model for strong factorial invariance can be specified as the previous model with the following addition [x11 x12 x13] (g h i);[x21 x22 x23] (g h i); ...
which ensures that the intercepts of the observed variables are constrained over time, and [WFX2* WFX3* ... ];
which implies that the latent means at each wave can differ from zero.
TITLE: Multiple indicator RI-CLPM, 5 waves, with 3 indicators for
each variable at each wave (30 observed variables) and with
random intercepts for each indicator separately. Fitting a model
with constraints to ensure strong factorial invariance.
DATA: FILE = RICLPM-MI.dat;
VARIABLE: NAMES = x11 x12 x13 x21 x22 x23 x31 x32 x33
x41 x42 x43 x51 x52 x53 y11 y12 y13
y21 y22 y23 y31 y32 y33 y41 y42 y43
y51 y52 y53;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: !!!!!!!!!!!!!!!!
! BETWEEN PART !
!!!!!!!!!!!!!!!!
! Create between factors (random intercepts) for each indicator separately
RIX1 BY x11@1 x21@1 x31@1 x41@1 x51@1;
RIX2 BY x12@1 x22@1 x32@1 x42@1 x52@1;
RIX3 BY x13@1 x23@1 x33@1 x43@1 x53@1;
RIY1 BY y11@1 y21@1 y31@1 y41@1 y51@1;
RIY2 BY y12@1 y22@1 y32@1 y42@1 y52@1;
RIY3 BY y13@1 y23@1 y33@1 y43@1 y53@1;
! Add covariances between all RIs
RIX1-RIY3 WITH RIX1-RIY3;
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: MEASUREMENT MODEL !
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! Due to having a random intercept per indicator, the measurement model
! here is only on the within part of the measurements
! Factor models for x at 5 waves
WFX1 BY x11-x13 (a b c);
WFX2 BY x21-x23 (a b c);
WFX3 BY x31-x33 (a b c);
WFX4 BY x41-x43 (a b c);
WFX5 BY x51-x53 (a b c);
! Factor models for y at 5 waves
WFY1 BY y11-y13 (d e f);
WFY2 BY y21-y23 (d e f);
WFY3 BY y31-y33 (d e f);
WFY4 BY y41-y43 (d e f);
WFY5 BY y51-y53 (d e f);
! Constrained intercepts over time (this is necessary
! for strong factorial invariance; without these
! constraints we have weak factorial invariance).
[x11 x12 x13] (g h i);
[x21 x22 x23] (g h i);
[x31 x32 x33] (g h i);
[x41 x42 x43] (g h i);
[x51 x52 x53] (g h i);
[y11 y12 y13] (j k l);
[y21 y22 y23] (j k l);
[y31 y32 y33] (j k l);
[y41 y42 y43] (j k l);
[y51 y52 y53] (j k l);
! Free latent means from second wave onward (only do
! this in combination with the constraints on the
! intercepts; without these, this would not be identified).
[WFX2* WFX3* WFX4* WFX5*];
[WFY2* WFY3* WFY4* WFY5*];
!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: DYNAMICS !
!!!!!!!!!!!!!!!!!!!!!!!!!
!  Estimate the correlations within the same wave
WFX1 WITH WFY1;
WFX2 WITH WFY2;
WFX3 WITH WFY3;
WFX4 WITH WFY4;
WFX5 WITH WFY5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
TITLE: Multiple indicator RI-CLPM, 5 waves with 3 indicators for each
variable at each wave (30 observed variables). Fitting a model
with constraints to ensure strong factorial invariance, with a
random intercept for each indicator separately, for which a
factor model is specified, with factor loadings equal to the
within- person factor loadings.
DATA: FILE = RICLPM-MI.dat;
VARIABLE: NAMES = x11 x12 x13 x21 x22 x23 x31 x32 x33
x41 x42 x43 x51 x52 x53 y11 y12 y13
y21 y22 y23 y31 y32 y33 y41 y42 y43
y51 y52 y53;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: !!!!!!!!!!!!!!!!
! BETWEEN PART !
!!!!!!!!!!!!!!!!
! Create between factors (random intercepts) for each indicator separately
RIX1 BY x11@1 x21@1 x31@1 x41@1 x51@1;
RIX2 BY x12@1 x22@1 x32@1 x42@1 x52@1;
RIX3 BY x13@1 x23@1 x33@1 x43@1 x53@1;
RIY1 BY y11@1 y21@1 y31@1 y41@1 y51@1;
RIY2 BY y12@1 y22@1 y32@1 y42@1 y52@1;
RIY3 BY y13@1 y23@1 y33@1 y43@1 y53@1;
! Create a single random intercept for all X-variables, and another
! for all Y-variables and constrain the factor loading to be identical
! to the within-person factor loadings.
RIX BY RIX1 RIX2 RIX3 (a b c);
RIY BY RIY1 RIY2 RIY3 (d e f);
! Add a covariance between these two higher-order random intercept.
RIX WITH RIY;
! Constrain measurement error variances of the second order factor
! model to zero.
RIX1-RIY3@0;
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: MEASUREMENT MODEL !
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! Due to having a random intercept per indicator, the measurement model
! here is only on the within part of the measurements
! Factor models for x at 5 waves
WFX1 BY x11-x13 (a b c);
WFX2 BY x21-x23 (a b c);
WFX3 BY x31-x33 (a b c);
WFX4 BY x41-x43 (a b c);
WFX5 BY x51-x53 (a b c);
! Factor models for y at 5 waves
WFY1 BY y11-y13 (d e f);
WFY2 BY y21-y23 (d e f);
WFY3 BY y31-y33 (d e f);
WFY4 BY y41-y43 (d e f);
WFY5 BY y51-y53 (d e f);
! Constrained intercepts over time (this is necessary for strong
! factorial invariance; without these constraints we have weak
! factorial invariance).
[x11 x12 x13] (g h i);
[x21 x22 x23] (g h i);
[x31 x32 x33] (g h i);
[x41 x42 x43] (g h i);
[x51 x52 x53] (g h i);
[y11 y12 y13] (j k l);
[y21 y22 y23] (j k l);
[y31 y32 y33] (j k l);
[y41 y42 y43] (j k l);
[y51 y52 y53] (j k l);
! Free latent means from second wave onward (only do this in
! combination with the constraints on the intercepts; without
! these, this would not be identified).
[WFX2* WFX3* WFX4* WFX5*];
[WFY2* WFY3* WFY4* WFY5*];
!!!!!!!!!!!!!!!!!!!!!!!!!
! WITHIN PART: DYNAMICS !
!!!!!!!!!!!!!!!!!!!!!!!!!
!  Estimate the correlations within the same wave
WFX1 WITH WFY1;
WFX2 WITH WFY2;
WFX3 WITH WFY3;
WFX4 WITH WFY4;
WFX5 WITH WFY5;
OUTPUT: TECH1 STDYX SAMPSTAT CINTERVAL;
We have to overrule the default of Mplus to include a term for measurement error when the BY
statement is used, through FX1@0 FX2@0 ...;
. The two random intercepts are allowed to be freely correlated with each other, through RIX WITH RIY;
.
TITLE: Multiple indicator RI-CLPM, 5 waves with 3 indicators for each
variable at each wave (30 observed variables). Fitting a model
with constraints to ensure strong factorial invariance, with
the RI-CLPM at the latent level.
DATA: FILE = RICLPM-MI.dat;
VARIABLE: NAMES = x11 x12 x13 x21 x22 x23 x31 x32 x33
x41 x42 x43 x51 x52 x53 y11 y12 y13
y21 y22 y23 y31 y32 y33 y41 y42 y43
y51 y52 y53;
ANALYSIS: MODEL = NOCOV; ! Sets all default covariances to zero
MODEL: !!!!!!!!!!!!!!!!!!!!!
! MEASUREMENT MODEL !
!!!!!!!!!!!!!!!!!!!!!
! Factor models for x at 5 waves constrained factor loadings
! over time.
FX1 BY x11-x13 (a b c);
FX2 BY x21-x23 (a b c);
FX3 BY x31-x33 (a b c);
FX4 BY x41-x43 (a b c);
FX5 BY x51-x53 (a b c);
! Factor models for y at 5 waves constrained factor loadings
! over time.
FY1 BY y11-y13 (d e f);
FY2 BY y21-y23 (d e f);
FY3 BY y31-y33 (d e f);
FY4 BY y41-y43 (d e f);
FY5 BY y51-y53 (d e f);
! Constrained intercepts over time (this is necessary for strong
! factorial invariance; without these constraints we have weak
! factorial invariance).
[x11 x12 x13] (g h i);
[x21 x22 x23] (g h i);
[x31 x32 x33] (g h i);
[x41 x42 x43] (g h i);
[x51 x52 x53] (g h i);
[y11 y12 y13] (j k l);
[y21 y22 y23] (j k l);
[y31 y32 y33] (j k l);
[y41 y42 y43] (j k l);
[y51 y52 y53] (j k l);
! Free latent means from t=2 onward (only do this in combination
! with the constraints on the intercepts; without these, this
! would not be identified).
[FX2* FX3* FX4* FX5*];
[FY2* FY3* FY4* FY5*];
!!!!!!!!!!!!!!!!
! BETWEEN PART !
!!!!!!!!!!!!!!!!
! Create between factors (random intercepts)
RIX BY FX1@1 FX2@1 FX3@1 FX4@1 FX5@1;
RIY BY FY1@1 FY2@1 FY3@1 FY4@1 FY5@1;
! Include covariance between the random intercepts
RIX WITH RIY;
! Set the residual variances of all FX and FY variables to zero.
FX1-FY5@0;
!!!!!!!!!!!!!!!
! WITHIN PART !
!!!!!!!!!!!!!!!
!  Specify the lagged effects between the within-person centered
! latent variables.
 Estimate the correlations within the same wave.


Oopsie, 404
This site currently has only one page.
Take me there!
I don't want you to be sad, so here is a nice kitten for you:


2 Chronicles 16:9
For the eyes of the LORD run to and fro throughout the whole earth, to show himself strong in the behalf of them whose heart is perfect toward him. Herein thou hast done foolishly: therefore from henceforth thou shalt have wars.


After locust swarms seen in Delhi, neem leaves and firecrackers to chase pests
Parts of Delhi have been placed on alert after a swarm of locusts invaded several suburbs and entered the national capital’s border areas on Saturday.
Residents in the National Capital Region (NCR), including rural west Delhi (Dwarka), Gurugram and Faridabad, saw thousands of the crop-destroying pests flying over the skies.
Click here for full read


Makes requests to a Redis instance
This module is itself a Redis client, with an added createClient
method for
creating further Redis clients. The clients have been promisified, so to use
the promise version, append Async
to method names.
Redis.getAsync('myKey').then(value => console.log(value));
- Source:
Methods
(static) createClient() → {RedisLib.Client}
Create a Redis client.
- Source:
Returns:
- Type
- RedisLib.Client
Example
Redis.createClient().then(subscriber => subscriber.subscribeAsync('channel'));


--- layout: post title: 'Minimal Marking: A Humane and Practical Approach' date: 2012-07-07 09:01:57.000000000 -07:00 type: post parent_id: '0' published: true pd: '' status: publish categories: - Classroom Talk - Guest Posts - Ideas for Teachers/Parents Elementary tags: - College Prep - Correcting Essays - Minimal Marking - writing author: login: k email: k@k display_name: mcary first_name: '' last_name: '' ---
Guest Post By: Aniya Wells
In the time we've spent on the student end of the student-teacher relationship. We've all had the experience, even the smartest among us. The teacher hands back an assignment to the class, and before you can even flip to the last page and check your grade, your heart sinks. Your essay is covered in corrections and amendments and suggestions, drowning in a sea of red ink it would take a Moses to clear away.
This is a profoundly discouraging sight for a student, to be sure, but it's also unhelpful, inasmuch as it turns the teacher into an editor who, unlike a real-life editor on a newspaper, for instance, is not a collaborator who will be accepting a next draft for publication. It sets the teacher up as an authoritarian voice and makes the act of turning in work seem like a trap set to catch the student.
Back in the 1980s, professor Richard Haswell published a paper entitled "Minimal Marking" [College English 45 (6):600-604] that outlines a system of the same name. It's a great alternative to correcting every little mistake that appears in a student's paper. While it's designed for college work, it can certainly be ported to younger grade levels.
It works like this: instead of correcting mistakes individually, a check mark is placed in the right margin of each line that contains an error (potentially two or three). The nature of the errors is not specified. The important part is to include some kind of process for submitting second drafts. Always remind students: real writing is rewriting!
Thus students learn to go back and correct their own errors, rather than receiving corrections handed down from on high in an accusatory-seeming manner. This way they have to actually search through their own writing and think about where the mistake may lie, a more engaging process that's less threatening and more empowering, and which makes them more likely to really internalize the lessons learned.
To really take this minimal marking to another level, some form of collaborative learning is advised. You could have conferences with students after the second draft is submitted, or break into small groups in between the two drafts to search through each others' work and find what the check marks stand for. Students could also keep an error log, and by getting to know the mistakes they were most prone to making, learn to avoid them in an atmosphere of curiosity rather than shame.
Besides the abovementioned benefits to your class, you'll find that not only can this method save you a lot of work as a teacher, it can help create a more constructive framework for addressing grammar and writing issues, so you'll feel less guilty when you break out the red pen to tackle that pile of papers!
Aniya Wells particularly loves reading and writing about online education, although her interests span different niches as well, including personal finance, parenting, sustainable living, and more. Accredited online degree programs are hard to find in the online morass of scams, so Aniya's ultimate goal is to help her readers figure out the maze of online education. She can be reached for questions or comments at aniyawells@k.


{% extends "base.html" %}
{% load static %}
{% block javascript_head %}
{{ block.super }}
{% endblock %}
{% block full_content %}
Company model available for all users and User model is available only for authenticated
Try to search for Company with name "Provider company" or User email<EMAIL_ADDRESS>Search


Adapter.bof and Adapter.eof are read-only boolean properties indicating that the dataset beginning (bof) or the dataset end (eof) is reached.
In this demo we have limited datasource consisting of 100 items starting from index 1. So initially we are at the left position of the available dataset, and that's why we see "Begin of file is reached" message. After some scrolling down bof is being turned to false. The first item is destroyed and can be retrieved again.


This editor will work with the Kawai K5 and Kawai K5m.
So instead of sending a patch to temporary memory, Edisyn writes the patch to patch number SID-12 (the very last one). This will erase and overwrite this patch and basically treat it as a scratch area.
The display has two parts: the lower part shows the harmonics level, and the upper part shows the choice of envelope (there are five choices: 0="off", 1, 2, 3, and 4). If you are in Full Mode (see the Global tab), then the harmonics from both voices are shown together with a little divider line. Otherwise only the harmonics from the displayed voice are shown.
You can constrain which harmonics will be affected by your editing. For example, if you constrain the harmonics to "Odd", then only the odd harmonics will be edited when you drag your mouse over them. The other harmonics will be drawn in gray to indicate that they are unaffected by you. Note that there are several more harmonics options available to you than in the K5's own editor.
You can also constrain which envelope will be set when you edit -- this is useful because it can be hard to precisely set the envelope using the display. If you constrain the envelope to "3" for example, the the only options you'll be able to set will be 3 and OFF.
Last, you can set the harmonics to one of several presets such as sawtooth or square waves.
Note that drawing on the harmonics display will normally be jumpy and glitchy because every change you make on the display sends an associated MIDI parameter sysex messages to the synth, and this requires a significant pause or the K5 will not respond properly. You can disable this in one of two ways: either Disconnect MIDI, or turn off "Sends Real Time Changes", both located in the MIDI menu. After that you should find drawing in the display to be much smoother (and various other operations, like setting a Preset, to be much faster).
| By | Sean Luke |
| Date | April 2018 |