Using React.createElement
is a bore and a chore when creating React-powered applications. The developers that used React, both inside and outside of Facebook, wanted an easier way to interact with the React API and hide all of the minutiae that comes with using React.createElement
. They invented a new language that sits on top of JavaScript called JavaScript eXtension, or JSX.
In this article, you will learn
React.createElement
callsBecause browsers don’t understand JSX, you have to use some tools to translate JSX into just plain old JavaScript. The main tool that you will use in almost every case is one called Babel. It is a tool that can convert versions of modern JavaScript into old version of JavaScript. It can convert future features of JavaScript into modern JavaScript. It can convert JSX into modern (or old) JavaScript.
However, using Babel by itself is like building a house with just a hammer. It’d be nice to have fancier tools to help you build that house. That’s where tools like Create React App come into play. Create React App uses Babel underneath and, then, adds a whole lot more. You’ll see more of **Create React App* as you progress through the course.
Here’s a function-based component using React.createElement
that has an h1
element with the content “Hello!”, a placeholder image, and a link to some search engine passed in through props.
const ExampleComponent = props => React.createElement(
React.Fragment,
null,
React.createElement('h1', null, 'Hello!'),
React.createElement('img', { src: 'images/150' }),
React.createElement('a', { href: props.searchUrl }, props.searchText),
);
You’ve likely seen that before. JSX allows you to get rid of all of the calls to React.createElement
and replace them with almost HTML-looking tags. Here’s what the above content looks like in JSX.
const ExampleComponent = props =>
<React.Fragment>

Hello!

{props.searchText}
</React.Fragment>
;
You can see Babel in action converting that JSX code above. Here’s a link to Babel already configured for you. Copy and paste that code above to see it transform back into React.createElement
invocations.
The React.Fragment
element contains the h1
, img
, and a
, just like it does in the React.createElement
version, except instead of using a method call to do it, it uses more familiar HTML-like tags. There’s one super big difference between the HTML that you know and what JSX expects. Can you see it?
Look at the end of the img
tag. See that “/” before the closing angle bracket? You must include that if the tag that you’re using doesn’t have a close tag. If you want to use those HTML element in your JSX, then you have to put the slash. The following table shows some common tags that you’d use and their JSX equivalent.
| HTML self-closing tag | JSX equivalent |
|---|---|

 |

 |

 |

 |
 |
 |
<input> |
<input /> |
<link> |
<link /> |
When you use the low-level React.createElement
function call, you pass the properties in as an object as the second argument. In JSX, you pass in properties as if they were attributes on the tag.
When you want to use a static value, just use a string literal like this.

becomes
And, when you want to pass in some data rather than a sting literal like above, you use curly braces to turn
{props.searchText}
into
The stuff inside the curly braces is just a JavaScript expression, so you could do something like this, if you wanted, to make the search text uppercase:

{props.searchText.toUpperCase()}

To use comments in JSX, you use curly braces (because that means its just a normal JavaScript expression) and block-level JavaScript comments.

This is JSX

{/* This is a comment in JSX */}

Please read DOM Elements in the React documentation to understand how property names work, as well as the special property names that React supports. You can be assessed on the following special attributes:
checked
className
dangerouslySetInnerHTML
htmlFor
onChange
style
value
Also, you can be assessed on knowing that React uses camel-case for its attribute names so attributes like maxlength
in HTML are maxLength
in React.
You will also see code like this in other React projects, as well as in code generated by tools. It is a function-based component that uses the function
keyword rather than an arrow function. Note the return
statement.
function App() {
return (

Hello!

Welcome to JSX.

);
}
You’ll see that the JSX block is wrapped in parentheses. This is due to the way that JavaScript handles something called “automatic semicolon insertion”. Here’s a simple example. What do you think the function returns? (Yes, this is a “trick question”.)
If the answer isn’t obvious, start Node on the command line, type it in exactly the way it is there, and try calling it with sum(1, 2)
.
You may be surprised to see that it returns undefined
. Here’s why: when JavaScript reads your source code, it tries to be “helpful”. When it reads the lines of your code, it asks, is each line a “complete” line? Is it and the following lines valid JavaScript expressions? If the answer is “yes”, then it will add a semicolon at the end of the line for you. When it reads the above “sum” function, the JavaScript runner “thinks” to itself:
return
i + j;
return;
i + j;
Now, your function, in the eyes of JavaScript, looks like this.
That function never gets to i + j
because it always returns “no value” on the first line. Yikes!
To get around that, you can add parentheses to tell JavaScript that “more is coming”.
Now, when JavaScript reads the line return (
, it “thinks” to itself, “Well, that’s not a complete expression. There must be more coming. I will not put a semicolon there.”
The same is true for functions containing JSX. The above code
function App() {
return (

Hello!

Welcome to JSX.

);
}
is equivalent to
function App() {
return (
React.createElement(
'div',
null,
React.createElement('h1', null, 'Hello!'),
React.createElement('div', null, 'Welcome to JSX.'),
)
);
}
Without the parentheses starting right after the return
keyword and ending after the outer call of React.createElement
, JavaScript would just stick a semicolon after the return
keyword and all of the fancy React stuff would get ignored.
The message is clear: if you use the return
keyword in a function to “return some JSX”, then make sure you wrap the JSX in parentheses.
That’s really all there is to JSX. You combine your knowledge of HTML and your knowledge of React.createElement
to allow the Babel tool to turn your code into plain old JavaScript for you. Specifically, you have seen the following conversions:
| Conversion type | JSX | JavaScript |
|---|---|---|
| tags |

 |
React.createElement('h1', null) |
| attributes |  |
React.createElement('img', { src: "foo.png" }) |
| variables |
{message}
 |
React.createElement('h1', null, message) |
You’ve also read about the special property names that React supports.
Finally, you learned about the frustrating side effect of “automatic semicolon insertion” and, if you do use the return
keyword in your functions, that you should wrap the JSX in parentheses to prevent JavaScript from not returning your code.


x4juli is a port of main parts of log4j
to the
J2SE Logging API.
The
default implementation is incomplete
and therefor still not widely used, even when introduced in J2SE 1.4.
x4juli provides logmanagers, formatters, handlers, and filters to fill the gap.
The interface and use of the original API has not been changed, you just have
to use the x4juli.jar and an appropriate configuration file to benefit from x4juli.
Additionally x4juli delivers a native implementation of the
Jakarta Commons Logging (JCL) API
and the
Simple Logging Facade for Java (SLF4J) API.
Help from everyone is welcome!
x4juli is hosted at BerliOS Developer.
Here you can download the actual version:


I graduated from the University of California, Berkeley in May 2016, with a Bachelor of Science degree in Engineering Mathematics and Statistics, and continued a Master Degree program in Accountancy at Golden Gate University.
My undergraduate degree offers me the solid background to apply analytical skills. I took courses in pure mathematics, applied mathematics, statistics, the physical sciences, and industrial engineering. Throughout my Master career, I gained an understanding of the business, legal, professional and ethical context. I also immersed in community outreach – served as the president of Chi Pi Alpha (GGU Accounting Club).
I always love to learn new things. I’ve recently accomplished a 12-week coding Bootcamp and learned full stack development. I found it really interesting to build out a web application, to turn an idea into reality. I love the process of discovering new things and gradually be more comfortable with them. I am passionate about data analysis, solving complex and interesting real world tasks, making informed decisions by digging into data.
Concentration: Industrial Engineering Operation Research
President of Chi Pi Alpha Accounting Club of GGU
Tools Used: HTML, CSS, JavaScript, jQuery, Python, Express.js, React.js, Node.js, Passport.js, SQL, MongoDB, Firebase, Bootstrap, Semantic, Git, Github, Heroku
Tools Used: Java, Git and IntelliJ
Tools Used: R studio, MS Office, Adobe Acrobat
Tools Used: Matlab, MS Office
Tools Used: AMPL (Liner programing software), MS Office, Adobe Acrobat
I enjoy baking cakes and pastries. It's also a good meditation for me to release from stress. I can even make some challenging desserts like macarons! Maybe I will open a bakery after retirement.
I love outdoor activities too. I took part in Berkeley marathons twice. I will join the bay-to-breaker 2018. I do this because I need to burn those suger from my desserts. lol


mygis.Admin.MapManager.Maps Class
Functions for the maps in the map manager
Item Index
Methods
addNewMapCheck
()
Used for client-validation when inserting new map name
allCheckClicked
-
elem
Handles the check button in the Map Manager
Parameters:
-
elem
ElementThe firing checkbox
appClicked
-
The
Handles clicking on an app name in the map grid. Selects the row and goes to "edit mode"
Parameters:
-
The
Integerrow index clicked
createMapGrid
()
Used to create the map grid in the map Manager
createNewMap
()
Creates a new map
getCurrentCenter
()
Gets the map's current center and replaces the corresponding map property
getCurrentExtent
()
Gets the map's current extent and replaces the corresponding map property
getCurrentZoom
()
Gets the map's current zoom level and replaces the corresponding map property
inputChanged
-
event
Handles the input change in map settings
Parameters:
-
event
ObjectThe triggering event object
mapSelected
()
Activates/deactivates some buttons when a map is selected
mapUnselected
()
Activates/deactivates some buttons when a map is unselected
newMapThumbSelected
-
result
This method is called after an image is selected in the Media Manager to replace the map's thumb
Parameters:
-
result
ObjectThe result of the Media Manager window
refreshMapGrid
()
Refreshes the list of maps from the server
replaceMapThumbAuto
()
Generates a new map thumbnail from its layers
replaceMapThumbDialog
()
Shows the file manager to replace a map thumb.
showAddNewMap
()
Shows a dialog window for inserting new map
singleCheckClicked
-
elem
Handles the clicking of the checkbox in each row at the Map Manager
Parameters:
-
elem
ElementThe checkbox clicked


Introduction
In building this site as a challenge on my way to the freecodecamp certification, I followed a few steps. These are the same steps I used when designing the three before this one. I will likely use the same method when I make the next one. If I separate out the steps, they would be as described in this list. I will go into detail about each step.
- Goals
- Content Frame
- CSS
- Media Query
- Test and Complete
I will not be going into detail about how I test the requirements of the site. It is truly very simple. Code.io has javascript set up with a test suite and it is as simple as pressing a few buttons. I will however be specific about about the first four.
Goals
This doesn't seem like a super important step because it does not include any coding. It is however the most important one. When I attack a challenge like this, it's important for me to know all the requirements of the challenge in order to pass. You could do them one at a time, but I have reason for seeing them all at the same time.
Sometimes, as in this challenge, difference requirements will be fulfilled the same way. For example, with this site, they want the layout of the CSS to change if the screen is bigger or smaller. They also want a media query. These can both be achieved using the same group of code. I will be using the media query to resolve the screen issue.
Content Framework
My next step is to create what I like to call a frame for the site. It uses simple text content and pictures as needed. When I figure out what I plan on writing out in the actual page, as in the finished project, then I can simply put that in in place of the placeholder text I make. Before typing these paragraphs, I had filler text in here such as "filler". It looked like this:

filler

And the HTML code that created that snippet of code showed:

Code Here

Now imagine that for 10 p tags and 5 code tags and 5 li's. As well as all the other header and nav requirements.
CSS
After creating my framework, I happened to write the actual content, but I didn't have to yet. That is a "step" that I can do at any time without affecting the page that much. Then, after the framework, I would design the visual aspects of the page. This means designing the boxes, the colors, placing all the elements inside the boxes and making sure everything is the right size and looks good.
As I mentioned, while typing this out, I have not yet created the CSS to make it look pretty, however I do have preliminary styles ready to be filled in. When I fill them in, I will do as stated above with the boxes the colors and the positioning. This takes a little longer because I have to fiddle with it.
Code Here
Code Here
Media Query
After I finish the preliminary CSS, the next step is to change the CSS when the screen is large enough. I have a media query prepared for this purpose. So, when the screen size is large enough, the CSS layout will change completely. Once this media query is complete, all that is left is to test and fix any problems with the site.
Code Here


{% extends 'site/home.html' %} {% load bootstrap3 %} {% block breadcrumbs %}
Please enter the titles of the most essential tools, topics, techniques, or technologies that are are vital to your work as a data scientist. You may enter multiple topics, each on their own line.
Think of answering a student or intern's question - what do I need to learn to be a data scientist?
Here are a few randomly selected previous answers to get you started →


Geode includes interfaces for defining and maintaining your own statistics.
The Geode package, org.apache.geode
, includes the following interfaces for defining and maintaining your own statistics:
- StatisticDescriptor. Describes an individual statistic. Each statistic has a name and information on the statistic it holds, such as its class type (long, int, etc.) and whether it is a counter that always increments, or a gauge that can vary in any manner.
- StatisticsType. Logical type that holds a list of
StatisticDescriptors
and provides access methods to them. TheStatisticDescriptors
contained by aStatisticsType
are each assigned a unique ID within the list.StatisticsType
is used to create aStatistics
instance. - Statistics. Instantiation of an existing
StatisticsType
object with methods for setting, incrementing, getting individualStatisticDescriptor
values, and setting a callback which will recompute the statistic’s value at configured sampling intervals. - StatisticsFactory. Creates instances of
Statistics
. You can also use it to create instances ofStatisticDescriptor
andStatisticsType
, because it implementsStatisticsTypeFactory
.DistributedSystem
is an instance ofStatisticsFactory
. - StatisticsTypeFactory. Creates instances of
StatisticDescriptor
andStatisticsType
.
The statistics interfaces are instantiated using statistics factory methods that are included in the package. For coding examples, see the online Java API documentation for StatisticsFactory
and StatisticsTypeFactory
.
As an example, an application server might collect statistics on each client session in order to
gauge whether client requests are being processed in a satisfactory manner. Long request queues or
long server response times could prompt some capacity-management action such as starting additional
application servers. To set this up, each session-state data point is identified and defined in a
StatisticDescriptor
instance. One instance might be a RequestsInQueue
gauge, a non-negative
integer that increments and decrements. Another could be a RequestCount
counter, an integer that
always increments. A list of these descriptors is used to instantiate a SessionStateStats
StatisticsType
. When a client connects, the application server uses the StatisticsType
object to
create a session-specific Statistics
object. The server then uses the Statistics
methods to
modify and retrieve the client’s statistics. The figures below illustrate the relationships between the
statistics interfaces and show the implementation of this use case.
The Statistics Interfaces
Each StatisticDescriptor
contains one piece of statistical information. StatisticalDesriptor
objects
are collected into a StatisticsType
. The StatisticsType
is instantiated to create a Statistics
object.
Statistics Implementation
The StatisticDescriptor
objects shown here hold three pieces of statistical information about client
session state. These are collected into a SessionStateStats StatisticsType
. With this type, the
server creates a Statistics
object for each client that connects.


new GueTask(name, dependencies, action)
constructor - Create a new task with dependencies and actions.
You must have either a dependency or an action.
You may have both dependencies and an action
Parameters:
| Name | Type | Description |
|---|---|---|
name |
String | Name of the task |
dependencies |
Array | function | Array of dependencies or the task action |
action |
function | Task action (function) |
- Source:
Example
// creates a task named foo that runs tasks a and b prior to // running Promise.resolve() new GueTask('foo',['a','b'],() =>{ return Promise.resolve(); }); // Creates a task named foo2 that just executes promise.resolve new GueTask('foo2', () =>{ return Promise.resolve(); } // Creates a task named foo3 that runs tasks a and b new GueTask('foo3', ['a','b'])
Methods
-
endAction()
-
endAction - Handles execute completion
- Source:
-
endActionWithError(message)
-
endActionWithError - end the action and emits an error
Parameters:
Name Type Description message
string The error message - Source:
-
getActionDuration() → {integer}
-
getActionDuration - Returns how long the action ran
- Source:
Returns:
Number of ms the action ran- Type
- integer
-
getTaskDuration() → {integer}
-
getTaskDuration - Returns how long the task ran
- Source:
Returns:
Number of ms the task ran- Type
- integer
-
hasDependencies() → {boolean}
-
hasDependencies - returns true if a task has dependencies
- Source:
Returns:
true if a task has dependencies- Type
- boolean
-
runAction() → {promise}
-
execute - executes the task's action This does not check/resolve dependencies
- Source:
Returns:
returns a promise for the running action- Type
- promise
-
startAction()
-
startAction - Handles execution start
- Source:
-
taskFinished()
-
endTask - Marks the task as done handles any task end activities. Currently just sets the end time and sends the end message to gueEvents
- Source:
-
taskFinishedWithError(message)
-
taskFinishedWithError - Marks a task as finished with an error emits the task failed event
Parameters:
Name Type Description message
string Error message - Source:
-
taskStarted()
-
beginTask - Marks the task as started handles any task start activities. Currently just sets the start time and sends the start message to gueEvents
- Source:


| Spacing | Values | Examples | Usage |
|---|---|---|---|
spacing-none |
0 |
||
spacing-extra-tight |
4px |
||
spacing-tight |
8px |
||
spacing-base-tight |
12px |
||
spacing-base |
16px |
||
spacing-loose |
20px |
||
spacing-extra-loose |
32px |
| Font Families | Values | Examples | Usage |
|---|---|---|---|
font-stack-base |
-apple-system, BlinkMacSystemFont, 'San Francisco', 'Segoe
UI', Roboto, 'Helvetica Neue', sans-serif
|
The quick brown fox jumps over the lazy dog.
|
|
font-stack-monospace |
Monaco, Consolas, 'Lucida Console', monospace
|
The quick brown fox jumps over the lazy dog.
|
| Background Colors | Values | Examples | Usage |
|---|---|---|---|
color-purple-darker |
#230051 |
||
color-purple-dark |
#50248f |
||
color-purple |
#9c6ade |
||
color-purple-light |
#e3d0ff |
||
color-purple-lighter |
#f6f0fd |
||
color-indigo-darker |
#000639 |
||
color-indigo-dark |
#202e78 |
||
color-indigo |
#5c6ac4 |
||
color-indigo-light |
#b3bcf5 |
||
color-indigo-lighter |
#f4f5fa |
||
color-blue-darker |
#001429 |
||
color-blue-dark |
#084e8a |
||
color-blue |
#006fbb |
||
color-blue-light |
#b4e1fa |
||
color-blue-lighter |
#ebf5fa |
||
color-teal-darker |
#003135 |
||
color-teal-dark |
#00848e |
||
color-teal |
#47c1bf |
||
color-teal-light |
#b7ecec |
||
color-teal-lighter |
#e0f5f5 |
||
color-green-darker |
#173630 |
||
color-green-dark |
#108043 |
||
color-green |
#50b83c |
||
color-green-light |
#bbe5b3 |
||
color-green-lighter |
#e3f1df |
||
color-yellow-darker |
#573b00 |
||
color-yellow-dark |
#8a6116 |
||
color-yellow |
#eec200 |
||
color-yellow-light |
#ffea8a |
||
color-yellow-lighter |
#fcf1cd |
||
color-orange-darker |
#4a1504 |
||
color-orange-dark |
#c05717 |
||
color-orange |
#f49342 |
||
color-orange-light |
#ffc58b |
||
color-orange-lighter |
#fcebdb |
||
color-red-darker |
#330101 |
||
color-red-dark |
#bf0711 |
||
color-red |
#de3618 |
||
color-red-light |
#fead9a |
||
color-red-lighter |
#fbeae5 |
||
color-ink |
#212b36 |
||
color-ink-light |
#454f5b |
||
color-ink-lighter |
#637381 |
||
color-ink-lightest |
#919eab |
||
color-sky-dark |
#c4cdd5 |
||
color-sky |
#dfe3e8 |
||
color-sky-light |
#f4f6f8 |
||
color-sky-lighter |
#f9fafb |
||
color-black |
#000000 |
||
color-white |
#ffffff |
| Text Colors | Values | Examples | Usage |
|---|---|---|---|
color-purple-text |
#50495a |
The quick brown fox jumps over the lazy dog. | |
color-indigo-text |
#3e4155 |
The quick brown fox jumps over the lazy dog. | |
color-blue-text |
#3e4e57 |
The quick brown fox jumps over the lazy dog. | |
color-teal-text |
#405352 |
The quick brown fox jumps over the lazy dog. | |
color-green-text |
#414f3e |
The quick brown fox jumps over the lazy dog. | |
color-yellow-text |
#595130 |
The quick brown fox jumps over the lazy dog. | |
color-orange-text |
#594430 |
The quick brown fox jumps over the lazy dog. | |
color-red-text |
#583c35 |
The quick brown fox jumps over the lazy dog. |
| Time | Values | Examples | Usage |
|---|---|---|---|
duration-none |
0 |
||
duration-fast |
100ms |
||
duration-base |
200ms |
||
duration-slow |
300ms |
||
duration-slower |
400ms |
||
duration-slowest |
500ms |


|
CMSIS-Pack
Version 1.7.2
Delivery Mechanism for Software Packs
|
There are multiple ways to distribute a software pack:
Before you start to distribute a software pack, you need to make sure that it does not contain errors. A good start is an error and warning free run of gen_pack.sh that does not show any PackChk errors and validates the XML of the PDSC file.
The easiest way to distribute a software pack is attaching it to an email or using other means of electronic distribution (for example using a company internal file server). The installation of a software pack is usually triggered by double-clicking the Pack file. The pack management tool is invoked and the Pack is installed on the local machine. After installation, the Pack will be shown in the list of installed packs (tool dependent). If the PDSC file does not contain a valid <url>
element, a manual installation is required to update a software pack. Otherwise, pack management tools can check for updates on the server or the local machine that is specified by <url>
.
<url>
using the file URI scheme.Any web server can be used to host a software pack (specified by the <url>
element in the PDSC file). At this location, the following files should be present:
All previous versions listed in the <releases> section of the PDSC file should be present at the <url>
as well. This allows users to revert updates or to download a previous version of a software pack (for maintenance purposes).
The <vendor>.pidx allows you to publish multiple packs to a Pack Index Service.
Several companies maintain a Pack Index Server to make packs available within tools or web pages. Once you are ready to deploy packs via such services, you may send the URL of the <vendor>.<name>.pdsc or <vendor>.pidx file to the following email addresses:
The *.pidx file allows you to change pack versions and add packs to your distribution list. All packs that are referenced in the .pidx file will be processed and validated. Only packs that pass the PackChk and schema check will become available via web pages and development tools.
For example, Arm uses the pack information to generate a list of available software packs. The following content will be processed in order to generate the web site (https://developer.arm.com/embedded/cmsis/cmsis-packs):
Please allow up to seven working days for the process. If the files contain any errors, you will be notified. Otherwise, the information is added to the index server.
Sometimes, it is necessary to rehost a pack (moving a pack from one URL to another). This implies that you need to change the <url> element in the PDSC file. To ensure that the pack is found by a Pack Index Service, follow this procedure:
Tool, software, or silicon vendors may provide a web infra-structure that lists packs that are available from multiple vendors. Companies like Arm or IAR provide a Pack Index Service that uses either a <vendor>.<name>.pdsc or a <vendor>.pidx file to obtain the latest pack versions. This information is used to make the packs available in the development tools (via a Pack Installer) and/or to publish information on certain web pages, for example a device list.
The following diagram explains how these services are working behind the scene.
Depending on the implementation, the web infra-structure may provide index files with additional information:


Topics:
Write a program that loads a triangle mesh model (with at least 100 triangles) from an smf file. smf files can be found here
Place at least two fixed white point light sources in your scene.
Calculate a surface normal for each triangle.
Calculate a diffuse (Lambertian) color for the triangle and assign the color to its three vertices. This will implement flat shading.
Implement a rotating camera view of the model. Your
camera should rotate on a cylinder around the model.
Allow the user to interactively change the height, the orbit
radius and speed of the camera.
The camera should rotate around and look at
the smf model (i.e. your LookAt point stays constant).
The user should be able to start and stop the
rotation of the camera.
Allow the user to select either parallel or perspective projection.
Here is a flat-shaded surface
Last modified February 3, 2015.


fsharp.org
github page
{project-name}
{document} {tooltips}
{project-name}
Home page
Get FsAlg via NuGet
GitHub Page
Release Notes
Getting Started
Vector Operations
Matrix Operations
Reference
API Reference


| Class | Description |
|---|---|
| ActivityInstance |
Represents the activity instance.
|
| ActivityStateMachine |
Handles the state for an activity instance.
|
| ControlNodeInstance |
Represents the abstract control node.
|
| DataAttributeInstance | |
| DataObjectInstance |
Represents data object instances.
|
| debugClass | |
| EmailAcceptanceTest |
Test the function of the email tasks.
|
| EmailTaskExecutionBehavior | |
| EventIncomingControlFlowBehavior |
Represents the incoming behavior of end events.
|
| EventInstance |
This class represents events.
|
| ExclusiveGatewayJoinBehavior | |
| ExclusiveGatewaySplitBehavior | |
| ExecutionAcceptanceTest |
Acceptance tests for the jcore.
|
| ExecutionService |
Handles all scenario instances.
|
| FragmentInstance |
Represents a fragment instance.
|
| GatewayInstance | |
| GatewayStateMachine | |
| HumanTaskExecutionBehavior | |
| IncomingBehavior | |
| OutgoingBehavior | |
| ParallelGatewayJoinBehavior | |
| ParallelGatewaySplitBehavior | |
| ParallelOutgoingBehavior | |
| ScenarioInstance |
Represents a scenario instance.
|
| StateMachine |
This is a abstract class for all state machines.
|
| TaskExecutionBehavior |
Performs the execution for one activity.
|
| TaskIncomingControlFlowBehavior | |
| TaskOutgoingControlFlowBehavior |
Handles the behavior of a terminating activity instance.
|
| WebServiceAcceptanceTest |
This class extends JerseyTest, because it's need the Rest Interface to check the Webservice Task functions.
|
| WebServiceTaskExecutionBehavior |
This is the execution behavior for webservice tasks
|
| XORGrammarCompiler |


To make the explanation easier to understand and illustrate the algorithm, I'll imagine a unit that can only wear Dagger, Fist and Accessories
In this phase, the builder will calculate all combinations of item type the unit can wear. First it will calculate "innate" combinations, meaning what the unit can wear without additional gear, then it will try to add more combination by pinning some available items, to give the unit Dual Wield, or allow other type of item to be equiped (if this option is checked)
Here is the result for my example unit, if I checked the 'Try "Allow use of
That's where the heavy work is done, and when the builder starts to use multiple threads to solve the BiS faster.
Basically, the builder iterates on the type combinations, and for each of them, find the BiS build that use that type combination. It then only keep the best build amongst those builds as the final result.
This phase can further be explained in two sub-phase. I'll explain them by focusing on one type combination :
Now that a type combination is fixed, two things can be done :
Resolved conditional items are added to the corresponding Item Pool, and number of item needed are adjusted :
All that is left is to try all the combinations of items kept. It's Brute Force time !
However, Item Pool have another precious feature : you can fetch a top level item from it, and it will update the remaining items. So if item B is overshadowed by better item A, you won't be able to fetch B from the item pool until you first fetch item A out of it. That allows to do a Brute Force approach, but also guarantee than an item won't be tried if all better items are not already used, in order to further improve performance


Biography
Dr. Makonin received a Ph.D. degree in computing science from Simon Fraser University (SFU), Burnaby, Canada, in 2014. He is an Adjunct Professor in the School of Engineering Science and the Principal Investigator of the Computational Sustainability Lab at Simon Fraser University (SFU). He also has the position of Head Instructor at SFU’s Big Data Hub, where he teaches data science and machine learning courses. He is a registered Professional Engineering (P.Eng.) with EGBC and has been a software engineer for over 25 years. Stephen is a Senior Member of the IEEE. He currently sits on the IEEE DataPort Advisory Committee, serves as the Editor in Chief of the IEEE DataPort Metadata Review Board, and serves as an Editorial Board Member of Nature’s Scientific Data journal. Additionally, he is the Vice-Chair of the Big Data Governance and Metadata Management (BDGMM, P2957).
Publications (Peer-Reviewed) [Citation data from Google Scholar]
Power/Energy Engineering & Smart Grid
-
Bundit Buddhahai, Stephen Makonin.
A Nonintrusive Load Monitoring Based on Multi-Target Regression Approach.
IEEE Access, vol. 9, pp.<PHONE_NUMBER>42 (2021). -
Alon Harell, Richard Jones, Stephen Makonin, Ivan V. Bajic.
TraceGAN: Synthesizing Appliance Power Signatures Using Generative Adversarial Networks.
IEEE Transactions on Smart Grid, vol. 12, no. 5, pp. 4553-4563 (2021). -
Md. Zulfiquar Ali Bhotto, Richard Jones, Stephen Makonin, Ivan V. Bajic.
Short-Term Demand Prediction Using an Ensemble of Linearly-Constrained Estimators.
IEEE Transactions on Power Systems, vol. 36, no. 4, pp. 3163-3175 (2021). -
Christoph Klemenjak, Stephen Makonin, Wilfried Elmenreich.
Investigating the performance gap between testing on real and denoised aggregates in non-intrusive load monitoring.
Energy Informatics, vol. 4, 3. 5, pp. 1-15 (2021). -
Richard Jones, Christoph Klemenjak, Stephen Makonin, Ivan V. Bajic.
Stop! Exploring Bayesian Surprise to Better Train NILM.
Proceedings of the 5th International Workshop on Non- Intrusive Load Monitoring, 2020. -
Shikha Singh, Angshul Majumdar, Stephen Makonin.
Compressive Non-Intrusive Load Monitoring.
Proceedings of the 7th ACM International Conference on Systems for Energy-Efficient Built Environments (BuildSys), 2020. -
Chinthaka Dinesh, Stephen Makonin, Ivan V. Bajic.
Residential Power Forecasting Based on Affinity Aggregation Spectral Clustering.
IEEE Access, vol. 8, pp. 99431-99444 (2020). -
Richard Jones, Alejandro Rodriguez-Silva, Stephen Makonin.
Increasing the Accuracy and Speed of Universal Non-Intrusive Load Monitoring (UNILM) Using a Novel Real-Time Steady-State Block Filter.
Proceedings of the 11th Conference on Innovative Smart Grid Technologies (ISGT), 2020. -
Christoph Klemenjak, Stephen Makonin, Wilfried Elmenreich.
Towards Comparability in Non-Intrusive Load Monitoring: On Data and Performance Evaluation.
Proceedings of the 11th Conference on Innovative Smart Grid Technologies (ISGT), 2020. -
Christoph Klemenjak, Anthony Faustine, Stephen Makonin, Wilfried Elmenreich.
On metrics to assess the transferability of machine learning models in non-intrusive load monitoring.
arXiv preprint arXiv:1912.06200, 2019. -
Megha Gaur, Stephen Makonin, Ivan V. Bajic, Angshul Majumdar.
Performance evaluation of techniques for identifying abnormal energy consumption in buildings.
IEEE Access, vol. 7, pp. 62721-62733 (2019). -
Alejandro Rodriguez-Silva, Stephen Makonin.
Universal Non-Intrusive Load Monitoring (UNILM) Using Filter Pipelines, Probabilistic Knapsack, and Labelled Partition Maps.
Proceedings of the 11th IEEE PES Asia-Pacific Power and Energy Engineering Conference 2019 (APPEEC), 2019. -
Alon Harell, Stephen Makonin, Ivan V. Bajic.
WaveNILM: A Causal Neural Network for Power Disaggregation from the Complex Power Signal.
Proceedings of the 44th International Conference on Acoustics, Speech, and Signal Processing (ICASSP), pp. 8335-8339, 2019. -
Chinthaka Dinesh, Stephen Makonin, Ivan V. Bajic.
Residential Power Forecasting Using Load Identification and Graph Spectral Clustering.
IEEE Transactions on Circuits and Systems II: Express Briefs, vol. 66, no. 11 , pp. 1900-1904 (2019). -
Alon Harell, Stephen Makonin, Ivan V. Bajic.
A Recurrent Neural Network for Multisensory Non-Intrusive Load Monitoring on a Raspberry Pi.
Proceedings of the IEEE 20th International Workshop on Multimedia Signal Processing (MMSP), 2018. -
Chinthaka Dinesh, Stephen Makonin, Ivan V. Bajic.
Incorporating Time-Of-Day Usage Patterns Into Non-Intrusive Load Monitoring.
Proceedings of the 5th IEEE Global Conference on Signal and Information Processing (GlobalSIP), 2017. -
Chinthaka Dinesh, Stephen Makonin, Ivan V. Bajic.
Understanding Appliance Power Consumption Without Sensors.
In Poster Session at the 3rd Annual IC-IMPACTS Research Conference, 2017.
-
Md. Zulfiquar Ali Bhotto, Stephen Makonin, Ivan V. Bajic.
Load disaggregation based on aided linear integer programming.
IEEE Transactions on Circuits and Systems II: Express Briefs, vol. 64, no. 7, pp. 792-796 (2016). -
Stephen Makonin.
Investigating the Switch Continuity Principle Assumed in Non-Intrusive Load Monitoring (NILM).
Proceedings of the 29th Annual IEEE Canadian Conference on Electrical and Computer Engineering (CCECE), 2016. -
Stephen Makonin, Fred Popowich, Ivan V. Bajic, Bob Gill, Lyn Bartram.
Exploiting HMM Sparsity to Perform Online Real-Time Nonintrusive Load Monitoring.
IEEE Transactions on Smart Grid, vol. 7, no. 6, pp. 2575-2585 (2016). -
Bradley Ellert, Stephen Makonin, Fred Popowich.
Appliance Water Disaggregation via Non-Intrusive Load Monitoring (NILM).
Proceedings of the EAI International Conference on Big Data and Analytics for Smart Cities (BigDASC), 2015. -
Stephen Makonin, Fred Popowich.
Nonintrusive Load Monitoring (NILM) Performance Evaluation.
Energy Efficiency, vol. 8, no. 4, pp. 809–814 (2015). -
Stephen Makonin.
Real-Time Embedded Low-Frequency Load Disaggregation.
PhD Thesis, Simon Fraser University, School of Computing Science, 2014. -
Stephen Makonin, Ivan V. Bajic, Fred Popowich.
Efficient Sparse Matrix Processing for Nonintrusive Load Monitoring (NILM).
Proceedings of the 2nd International Workshop on Non-Intrusive Load Monitoring, 2014. -
Stephen Makonin, Laura Guzman Flores, Robyn Gill, Roger Alex Clapp, Lyn Bartram, Bob Gill.
A Consumer Bill of Rights for Energy Conservation.
Proceedings of the IEEE Canada International Humanitarian Technology Conference (IHTC), 2014. -
Stephen Makonin
Nonintrusive Load Monitoring (NILM): What an algorithm can tell you about your energy consumption.
In Poster Session at SFU Postdoctoral Research Day, 2016.
In Poster Session at IEEE Vancouver Section Annual General Meeting, 2014.
-
Stephen Makonin, William Sung, Ryan Dela Cruz, Brett Yarrow, Bob Gill, Fred Popowich, Ivan V. Bajic.
Inspiring Energy Conservation Through Open Source Metering Hardware and Embedded Real-Time Load Disaggregation.
Proceedings of the 5th IEEE PES Asia-Pacific Power and Energy Engineering Conference (APPEEC), 2013. -
Stephen Makonin, Fred Popowich, Bob Gill.
The Cognitive Power Meter: Looking Beyond the Smart Meter.
Proceedings of the 26th Annual IEEE Canadian Conference on Electrical and Computer Engineering (CCECE), 2013. -
Stephen Makonin.
Approaches to Non-Intrusive Load Monitoring (NILM) in the Home.
PhD depth report, Simon Fraser University, School of Computing Science, 2012.
Data Engineering, Public Datasets & Big Data
-
Mostafa Farrokhabadi, Jethro Browell, Yi Wang, Stephen Makonin, Wencong Su, Hamidreza Zareipour.
Day-Ahead Electricity Demand Forecasting Competition: Post-COVID Paradigm.
IEEE Open Access Journal of Power and Energy, Early Access (2022), -
Christoph Klemenjak, Andreas Reinhardt, Lucas Pereira, Stephen Makonin, Mario Bergés, Wilfried Elmenreich.
Electricity Consumption Data Sets: Pitfalls and Opportunities.
Proceedings of the 6th ACM International Conference on Systems for Energy-Efficient Built Environments, Cities, and Transportation (BuildSys), 2019. -
Stephen Makonin.
HUE: The Hourly Usage of Energy Dataset for Buildings in British Columbia.
Data in Brief, vol. 23, no. 103744, pp. 1-4 (2019). -
Stephen Makonin, Z. Jane Wang, Chris Tumpach.
RAE: The Rainforest Automation Energy Dataset for Smart Grid Meter Data Analysis.
Data, vol. 3, no. 1, article 7, pp. 1-9 (2018) -
Stephen Makonin, Bradley Ellert, Ivan V. Bajic, Fred Popowich.
Electricity, water, and natural gas consumption of a residential house in Canada from 2012 to 2014.
Scientific Data, vol. 3, no. 160037, pp. 1-12 (2016). -
Stephen Makonin, Fred Popowich, Lyn Bartram, Bob Gill, Ivan V. Bajic.
AMPds: A Public Dataset for Load Disaggregation and Eco-Feedback Research.
Proceedings of the 2013 IEEE Electrical Power and Energy Conference (EPEC), 2013. -
Stephen Makonin.
ODDs: Occupancy Detection Dataset.
Harvard Dataverse, V1, 2010.
Software Engineering, incl. ECE \amp; ICT
-
Stephen Makonin, Laura U. Marks, Radek Przedpelski, Alejandro Rodriguez-Silva, Ramy ElMallah.
Calculating the Carbon Footprint of Streaming Media: Beyond the Myth of Efficiency.
Proceedings of LIMITS 2022, Eighth Workshop on Computing within Limits, 2022. -
Stephen Makonin.
Start-Up Creation: The Smart Eco-Efficient Built Environment.
Editors: Fernando Pacheco-Torgal, Erik Rasmussen, Claes-Goran Granqvist, Volodymyr Ivanov, Arturas Kaklauskas, Stephen Makonin.
1st Ed. Woodhead Publishing, ISBN: 978-0-08-100546-0 (hardcover), 978-0-08-100549-1 (ebook), 2016.
2st Ed. Woodhead Publishing, ISBN: 978-0-12-819946-6 (paperback), 978-0-12-819947-3 (ebook), 2020. -
Laura Guzman, Stephen Makonin, Roger Alex Clapp.
CarbonKit: Designing A Personal Carbon Tracking Platform.
Proceedings of SocialSense ’19: Fourth International Workshop on Social Sensing, pp. 24-29, 2019. -
Joanna Wallace, Kyle Richardson, Bob Gill, Stephen Makonin.
Cognitive Radio Technology: System Evolution.
Proceedings of the 4th International Conference On Wireless Networks and Embedded Systems (WECON), 2015. -
Reza Filsoof, Alison Bodine, Bob Gill, Stephen Makonin, Robert Nicholson.
Transmitting Patient Vitals Over a Reliable ZigBee Mesh Network.
Proceedings of the IEEE Canada International Humanitarian Technology Conference (IHTC), 2014. -
David Bennett, Stephen Makonin, Vincent W. Mayfield, Ted Neustaedter, Mark R. Wrenn.
Visual C++ 5.0 Developer's Guide.
Sams Publishing, ISBN: 978-0-672-31031-7, 1996.
Visualization & Human-Computer Interaction (HCI)
-
Stephen Makonin, Daniel McVeigh, Wolfgang Stuerzlinger, Khoa Tran, Fred Popowich.
Mixed-Initiative for Big Data: The Intersection of Human + Visual Analytics + Prediction.
Proceedings of the 49th Hawaii International Conference on System Sciences (HICSS), pp. 1427-1436, 2016. -
Stephen Makonin, Lyn Bartram, Fred Popowich.
A Smarter Smart Home: Case Studies of Ambient Intelligence.
IEEE Pervasive Computing, vol. 12, no. 1, pp. 58–66 (2013). -
Stephen Makonin, Fred Popowich, TaeJin Moon, Bob Gill.
Inspiring Energy Conservation Through Open Source Power Monitoring and In-Home Display.
Proceedings of the IEEE Power and Energy Society General Meeting, 2013. -
Stephen Makonin, Fred Popowich.
Home Occupancy Agent: Occupancy and Sleep Detection.
GSTF Journal on Computing, vol. 2, no. 1, pp. 182–186 (2012). -
Stephen Makonin, Maryam H. Kashani, Lyn Bartram.
The Affect of Lifestyle Factors on Eco-Visualization Design.
Proceedings of Computer Graphics International (CGI), 2012. -
Stephen Makonin, Philippe Pasquier, Lyn Bartram.
Elements of Consumption: An abstract visualization of household consumption.
Proceedings of the 11th International Symposium on Smart Graphics, LNSC 6815:194–198, 2011. -
Stephen Makonin, Fred Popowich.
An intelligent agent for determining home occupancy using power monitors and light sensors.
Proceedings of the 9th International Conference on Smart Homes and Health Telematics (ICOST), LNSC 6719:236–240, 2011.
Academic Exploits
Current Supervision
-
Maria Tu — MASc Thesis (Senior Supervisor, Jan/2021 to present)
Thesis: tbd (subject area: NILM, Modelling, Data and Software Engineering)
Past Supervision
-
Md. Zulfiquar Ali Bhotto — Postdoctoral Fellow (Co-Supervisor, Dec/2017 to Dec/2021)
Research subject area: Adaptive Filters, Optimization, Machine Learning, Power Grid
-
Alejandro Rodriguez-Silva — MASc Thesis (Senior Supervisor, Jan/2018 to Dec/2021)
Thesis: Filtering in Non-Intrusive Load Monitoring
-
Richard Jones — MASc Thesis (Senior Supervisor, May/2019 to Dec/2020)
Thesis: Non-Parametric Modeling in Non-Intrusive Load Monitoring
Awards: GDES Entrance Scholarship, NSERC CGS-M
-
Alon Harell — MASc Thesis (Co-Supervisor, May/2018 to Aug/2020)
Thesis: Deep Learning Applications in Non-Intrusive Load Monitoring
Awards: NSERC CGS-M
-
Bradley Ellert — MSc Thesis (Co-Supervisor, defended Aug 17, 2015)
Thesis: Leveraging Submetered Electricity Loads to Disaggregate Household Water-Use
Visiting Scholars
-
Keke Li (李可可) — Visiting Masters Scholar from Northeastern University, China (Sep/2020 to now, virtual)
-
David Murray — Visiting PhD Scholar from University of Strathclyde, UK (Jul/2019 to Aug/2019, 2 months)
-
Bundit Buddhahai — Visiting PhD Scholar from KMUTT, Thailand (May/2019 to Oct/2019, 6 months)
-
Christoph Klemenjak — Visiting PhD Scholar from University of Klagenfurt, Austria (May/2019 to Aug/2019, 3 months)
-
Shikha Singh — Visiting PhD Scholar from IIIT-Delhi, India (Jul/2018, ½ month)
Grant: IC-IMPACTS NCE and India DST -
Megha Gaur — Visiting PhD Scholar from IIIT-Delhi, India (Sep/2017 to Feb/2018, 6 months)
Grant: IC-IMPACTS NCE and India DST
Research Grants [PI = Principal Investigator]
- Co-Principal Investigator — SSHRC Knowledge Synthesis Grant ($50,000 over 1 year), 2020
Title: Tackling the Carbon Footprint of Streaming Media - Principal Investigator — NSERC Engage Grant ($25,000 over 6 months), 2019
Title: Inferring power grid transformer to meter association using inconsistent geospatial data - Investigator — European Commission Horizon2020 Grant (2 years)
Title: SENSors and Intelligence in BuLt Environment (SENSIBLE) project
[indirect moneys to allow for grad student visits] - Principal Investigator — NSERC Discovery Launch Supplement Award ($12,500), 2019
- Principal Investigator — NSERC Discovery Grant ($140,000 over 5 years), 2018
Title: Non-Intrusive Load Monitoring - Postdoc — IC-IMPACTS NCE Project Grant ($133,000, 2 years, 11.2% success rate)
Title: Energy and Water Disaggregation for Non-Intrusive Load Monitoring in Buildings
[I was a main author and organizer of grant but could not be co-PI due to funding rules] - PhD Candidate — SFU GSS Professional Development Grant ($500), 2014
- Principal Investigator — BCIT School of Energy Research Seed Funding ($10,000 over 4 months), 2013
Title: Branch Circuit Ammeter and Data Logger for Smart Grid/Home Application - PhD Candidate — SFU GSS Professional Development Grant ($500), 2012
Course Instruction
-
SFU Data Fellowships - A series of short, part-time courses that offers foundational data science and AI concepts.
Simon Fraser University, SFU'S Big Data Hub: 2021 (Feb/Apr/Jun/Oct) -
CMPT 165 - Introduction to the Internet and the World Wide Web
Simon Fraser University, School of Computing Science: Fall/2014, Spring/2015.
Awards & Achievements
Service To Profession
Advisory Boards/Committees
- Advisory Board Member, IEEE DataPort, 2020 — now
- Faculty Advisory Member, SFU Sustainability Advisory Council (S-AC), 2021 — now
Journal Editorship
- Editor in Chief, Metadata Review Board,IEEE DataPort, 2020 — now
- Editorial Board Member, Scientific Data, Nature, 2019 — now
-
Guest Editorial Board Member, Open Access Journal of Power and Energy,IEEE, 2021 — now
Special Section: COVID-19 Impact on Electrical Grid Operation: Analysis and Mitigation
Standards Associations
-
Voting Member, Big Data Governance and Metadata Management (IEEE P2957 BDGMMWG)
Chiar, Implementation Testbed Subgroup
IEEE Standards Association (IEEE SA) & NIST (USA)
General Chair/Co-Chair & Organizer
- 5th International Workshop on Non-Intrusive Load Monitoring (NILM), Yokohama Japan, 2020
- Advanced Signal Processing for Non-intrusive Load Monitoring Special Session at ICASSP, Brighton UK, 2019
- 4th International Workshop on Non-Intrusive Load Monitoring (NILM), Austin USA, 2018
- The Plenty of Fish (POF) 24hr Hackathon, Vancouver Canada, 2017
- 3rd International Workshop on Non-Intrusive Load Monitoring (NILM), Vancouver Canada, 2016
- IEEE Vancouver Windows 10 Hackathon (28-hours), Vancouver Canada, 2015
- IEEE Vancouver Kinect and Structure Sensor Hackathon (28-hours), Vancouver Canada, 2014
Website & Social Media Chair
- 14th IEEE International NEW Circuits And Systems (NEWCAS) Conference, 2016
- 29th Annual IEEE Canadian Conference on Electrical and Computer Engineering (CCECE), 2016
- IEEE 15th International Conference on High Performance Switching and Routing (HPSR), 2014
Local Arrangements Chair
- IEEE 20th International Workshop on Multimedia Signal Processing (MMSP), 2018
- IEEE World Congress on Computational Intelligence (WCCI), 2016
Technical Program Committee
- eSim 2020 Conference, International Building Performance Simulation Association (IBPSA-Canada): 2020
- 11th IEEE PES Asia-Pacific Power and Energy Engineering Conference (APPEEC): 2019
- 5th IFIP Conference on Sustainable Internet and ICT for Sustainability (SustainIT): 2017
- IEEE Workshop on Pervasive Energy Services (PerEnergy): 2015, 2016, 2017
- 3rd International Workshop on Computational Energy Management in Smart Grids (CEMiSG): 2016
- EAI International Conference on Big Data and Analytics for Smart Cities (BigDASC): 2015
- International Conference on Ubiquitous Computing & Ambient Intelligence (UCAmI): 2011—2015
- IEEE International Conference on Power and Energy (PECON): 2012
Software Engineering Services
Long before he completed his graduate studies, Dr. Makonin founded his professions consulting company in 1996. Since then, he has earned prestige for its development of complex billing, manufacturing and customer care systems and its streamlining of mass dynamic data and legacy system conversions. Highly regarded as an expert architect of high-speed data conversion tools and processing utilities, Dr. Makonin is also respected for his research scientist, project management, data engineering, and software engineering skills; this includes technical writing and editing. An ability to master emerging languages and technologies on the fly gives him the edge in today's fast-paced work environments.
Dr. Makonin is proud of his reputation and continues to build upon that reputation by supplying distinctive, quality components, libraries, and applications. HE has provided quality solutions and is committed to excellence and customer satisfaction. His innovative solutions are: constructed to ease the burden of unwieldy administration; developed using the latest, progressive technology; as dynamic-looking as they are functional; designed for 99% uptime on mission-critical applications; reliable and secure; fully documented; and cost-effective.
Full SDLC Services for Application and Web Development including:
- Conceptual Phase — preliminary evaluation including feasibility studies and preliminary risk assessments;
- Definition Phase — definition of requisite resources, time cost and performance estimates;
- Production Phase — building the end product including support documentation;
- Operation Phase — integration of the end product into the organizational environment; and,
- Divestment Phase — reallocation of resources and post-implementation evaluation.
Application Design and Development including:
Development and design of components, databases, applications, tools and internet features including but not limited to:
- audits and authentication of user logins;
- batch programs to FTP and email files to and from the server;
- batch programs to streamline databases;
- billing and bill inquiry systems including internet billing, auto-billing mailouts, billing engines, and built-in secure encryption modules;
- conversions (database to server, binary switch data to ASCII records, legacy systems to client-server);
- customer care systems;
- data maintenance applications;
- database synchronization applications;
- high-speed data conversion tools;
- interactive games;
- libraries to import address book formats into the mail system;
- mail activity logs including reports detailing usage statistics;
- mass dynamic data conversion;
- n-tier solutions;
- objects, screens and screen prototypes;
- optimized database access to eliminate speed issues;
- processing utilities;
- promotions and new service offerings;
- returned merchandise authorization;
- test utilities to simulate user load on servers;
- utilities to resolve binary compatibility issues or to compile projects;
- validation and/or formatting of data; and,
- workflows to automate communication and eliminate paperwork.
Internet Development including:
- Creation of internet calendars for internal and/or external organizations;
- Development of internetwork order tracking systems that can be easily utilized by employees;
- Building of intranets containing contact information and valuable features specific to the client environment;
- Setup of newsgroups to facilitate workplace discussions;
- Design of screens for any web-based application;
- Hosting setup and enhancement of internet access capabilities;
- Design of websites for data querying and server/scheduler configuration;
- User and affiliate sign up utilities; and,
- Modification of current websites or site construction from scratch.


This is the API
https://localhost:8080/api/v1/file-payment-consents
POST
Default
An Authorisation Token as per https://tools.ietf.org/html/rfc6750
Every request will be processed only once per x-idempotency-key. The Idempotency Key will be valid for 24 hours.
A detached JWS signature of the body of the payload.
The time when the PSU last logged in with the TPP. All dates in the HTTP headers are represented as RFC 7231 Full Dates. An example is below: Sun, 10 Sep 2017 19:43:31 UTC
The PSU's IP address if the PSU is currently logged in with the TPP.
An RFC4122 UID used as a correlation id.
https://localhost:8080/api/v1/file-payment-consents/{ConsentId}/file
POST
Default
ConsentId
An Authorisation Token as per https://tools.ietf.org/html/rfc6750
Every request will be processed only once per x-idempotency-key. The Idempotency Key will be valid for 24 hours.
A detached JWS signature of the body of the payload.
The time when the PSU last logged in with the TPP. All dates in the HTTP headers are represented as RFC 7231 Full Dates. An example is below: Sun, 10 Sep 2017 19:43:31 UTC
The PSU's IP address if the PSU is currently logged in with the TPP.
An RFC4122 UID used as a correlation id.
https://localhost:8080/api/v1/file-payments
POST
Default
An Authorisation Token as per https://tools.ietf.org/html/rfc6750
Every request will be processed only once per x-idempotency-key. The Idempotency Key will be valid for 24 hours.
A detached JWS signature of the body of the payload.
The time when the PSU last logged in with the TPP. All dates in the HTTP headers are represented as RFC 7231 Full Dates. An example is below: Sun, 10 Sep 2017 19:43:31 UTC
The PSU's IP address if the PSU is currently logged in with the TPP.
An RFC4122 UID used as a correlation id.
https://localhost:8080/api/v1/file-payment-consents/{ConsentId}
GET
ConsentId
An Authorisation Token as per https://tools.ietf.org/html/rfc6750
The time when the PSU last logged in with the TPP. All dates in the HTTP headers are represented as RFC 7231 Full Dates. An example is below: Sun, 10 Sep 2017 19:43:31 UTC
The PSU's IP address if the PSU is currently logged in with the TPP.
An RFC4122 UID used as a correlation id.
https://localhost:8080/api/v1/file-payment-consents/{ConsentId}/file
GET
ConsentId
An Authorisation Token as per https://tools.ietf.org/html/rfc6750
The time when the PSU last logged in with the TPP. All dates in the HTTP headers are represented as RFC 7231 Full Dates. An example is below: Sun, 10 Sep 2017 19:43:31 UTC
The PSU's IP address if the PSU is currently logged in with the TPP.
An RFC4122 UID used as a correlation id.
https://localhost:8080/api/v1/file-payments/{FilePaymentId}
GET
FilePaymentId
An Authorisation Token as per https://tools.ietf.org/html/rfc6750
The time when the PSU last logged in with the TPP. All dates in the HTTP headers are represented as RFC 7231 Full Dates. An example is below: Sun, 10 Sep 2017 19:43:31 UTC
The PSU's IP address if the PSU is currently logged in with the TPP.
An RFC4122 UID used as a correlation id.
https://localhost:8080/api/v1/file-payments/{FilePaymentId}/report-file
GET
FilePaymentId
An Authorisation Token as per https://tools.ietf.org/html/rfc6750
The time when the PSU last logged in with the TPP. All dates in the HTTP headers are represented as RFC 7231 Full Dates. An example is below: Sun, 10 Sep 2017 19:43:31 UTC
The PSU's IP address if the PSU is currently logged in with the TPP.
An RFC4122 UID used as a correlation id.


Class TextIO
- java.lang.Object
-
- TextIO
-
public class TextIO extends java.lang.Object
TextIO provides a set of static methods for reading and writing text. By default, it reads from standard input and writes to standard output, but it is possible to redirect the input and output to files or to other input and output streams. When the standard input and output streams are being used, the input methods will not produce an error; instead, the user is repeatedly prompted for input until a legal input is entered. (If standard input has been changed externally, as by file redirection on the command line, this is not a reasonable behavior; to handle this case, TextIO will give up after 10 consecutive illegal inputs and will throw an IllegalArgumentException.) For the most part, any other error will be translated into an IllegalArguementException.For writing to standard output, the output methods in this class pretty much duplicate the functionality of System.out, and System.out can be used interchangeably with them.
This class does not use optimal Java programming practices. It is designed specifically to be easily usable even by a beginning programmer who has not yet learned about objects and exceptions. Therefore, everything is in a single source file that compiles into a single class file, all the methods are static methods, and none of the methods throw exceptions that would require try...catch statements. Also for this reason, all exceptions are converted into IllegalArgumentExceptions, even when this exception type doesn't really make sense.
This class requires Java 5.0 or higher. (A previous version of TextIO required only Java 1.1; this version should work with any source code that used the previous version, but it has some new features, including the type of formatted output that was introduced in Java 5 and the ability to use files and streams.)
-
-
Constructor Summary
Constructors Constructor Description TextIO()
-
Method Summary
All Methods Static Methods Concrete Methods Modifier and Type Method Description static boolean
eof()
Test whether the next character in the current input source is an end-of-file.static boolean
eoln()
Test whether the next character in the current input source is an end-of-line.static char
getAnyChar()
Reads the next character from the current input source.static boolean
getBoolean()
Skips whitespace characters and then reads a value of type boolean from input.static byte
getByte()
Skips whitespace characters and then reads a value of type byte from input.static char
getChar()
Skips whitespace characters and then reads a single non-whitespace character from input.static double
getDouble()
Skips whitespace characters and then reads a value of type double from input.static float
getFloat()
Skips whitespace characters and then reads a value of type float from input.static java.lang.String
getInputFileName()
If TextIO is currently reading from a file, then the return value is the name of the file.static int
getInt()
Skips whitespace characters and then reads a value of type int from input.static java.lang.String
getln()
Reads all the characters from the current input source, up to the next end-of-line.static boolean
getlnBoolean()
Skips whitespace characters and then reads a value of type boolean from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static byte
getlnByte()
Skips whitespace characters and then reads a value of type byte from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static char
getlnChar()
Skips whitespace characters and then reads a value of type char from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static double
getlnDouble()
Skips whitespace characters and then reads a value of type double from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static float
getlnFloat()
Skips whitespace characters and then reads a value of type float from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static int
getlnInt()
Skips whitespace characters and then reads a value of type int from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static long
getlnLong()
Skips whitespace characters and then reads a value of type long from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static short
getlnShort()
Skips whitespace characters and then reads a value of type short from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static java.lang.String
getlnString()
This is identical to getln().static java.lang.String
getlnWord()
Skips whitespace characters and then reads one "word" from input, discarding the rest of the current line of input (including the next end-of-line character, if any).static long
getLong()
Skips whitespace characters and then reads a value of type long from input.static java.lang.String
getOutputFileName()
If TextIO is currently writing to a file, then the return value is the name of the file.static short
getShort()
Skips whitespace characters and then reads a value of type short from input.static java.lang.String
getWord()
Skips whitespace characters and then reads one "word" from input.static char
peek()
Returns the next character in the current input source, without actually removing that character from the input.static void
put(java.lang.Object x)
Write a single value to the current output destination, using the default format and no extra spaces.static void
put(java.lang.Object x, int minChars)
Write a single value to the current output destination, using the default format and outputting at least minChars characters (with extra spaces added before the output value if necessary).static void
putf(java.lang.String format, java.lang.Object... items)
Writes formatted output values to the current output destination.static void
putln()
Write an end-of-line character to the current output destination.static void
putln(java.lang.Object x)
This is equivalent to put(x), followed by an end-of-line.static void
putln(java.lang.Object x, int minChars)
This is equivalent to put(x,minChars), followed by an end-of-line.static void
readFile(java.lang.String fileName)
Opens a file with a specified name for input.static void
readStandardInput()
After this method is called, input will be read from standard input (as it is in the default state).static void
readStream(java.io.InputStream inputStream)
After this method is called, input will be read from inputStream, provided it is non-null.static void
readStream(java.io.Reader inputStream)
After this method is called, input will be read from inputStream, provided it is non-null.static boolean
readUserSelectedFile()
Puts a GUI file-selection dialog box on the screen in which the user can select an input file.static void
skipBlanks()
Skips over any whitespace characters, except for end-of-lines.static void
writeFile(java.lang.String fileName)
Opens a file with a specified name for output.static void
writeStandardOutput()
After this method is called, output will be written to standard output (as it is in the default state).static void
writeStream(java.io.OutputStream outputStream)
After this method is called, output will be sent to outputStream, provided it is non-null.static void
writeStream(java.io.PrintWriter outputStream)
After this method is called, output will be sent to outputStream, provided it is non-null.static boolean
writeUserSelectedFile()
Puts a GUI file-selection dialog box on the screen in which the user can select an output file.
-
-
-
Field Detail
-
EOF
public static final char EOF
The value returned by the peek() method when the input is at end-of-file. (The value of this constant is (char)0xFFFF.)- See Also:
- Constant Field Values
-
EOLN
public static final char EOLN
The value returned by the peek() method when the input is at end-of-line. The value of this constant is the character '\n'.- See Also:
- Constant Field Values
-
-
Method Detail
-
readStandardInput
public static void readStandardInput()
After this method is called, input will be read from standard input (as it is in the default state). If a file or stream was previously the input source, that file or stream is closed.
-
readStream
public static void readStream(java.io.InputStream inputStream)
After this method is called, input will be read from inputStream, provided it is non-null. If inputStream is null, then this method has the same effect as calling readStandardInput(); that is, future input will come from the standard input stream.
-
readStream
public static void readStream(java.io.Reader inputStream)
After this method is called, input will be read from inputStream, provided it is non-null. If inputStream is null, then this method has the same effect as calling readStandardInput(); that is, future input will come from the standard input stream.
-
readFile
public static void readFile(java.lang.String fileName)
Opens a file with a specified name for input. If the file name is null, this has the same effect as calling readStandardInput(); that is, input will be read from standard input. If an error occurs while trying to open the file, an exception of type IllegalArgumentException is thrown, and the input source is not changed. If the file is opened successfully, then after this method is called, all of the input routines will read from the file, instead of from standard input.
-
readUserSelectedFile
public static boolean readUserSelectedFile()
Puts a GUI file-selection dialog box on the screen in which the user can select an input file. If the user cancels the dialog instead of selecting a file, it is not considered an error, but the return value of the subroutine is false. If the user does select a file, but there is an error while trying to open the file, then an exception of type IllegalArgumentException is thrown. Finally, if the user selects a file and it is successfully opened, then the return value of the subroutine is true, and the input routines will read from the file, instead of from standard input. If the user cancels, or if any error occurs, then the previous input source is not changed.NOTE: Calling this method starts a GUI user interface thread, which can continue to run even if the thread that runs the main program ends. If you use this method in a non-GUI program, it might be necessary to call System.exit(0) at the end of the main() routine to shut down the Java virtual machine completely.
-
writeStandardOutput
public static void writeStandardOutput()
After this method is called, output will be written to standard output (as it is in the default state). If a file or stream was previously open for output, it will be closed.
-
writeStream
public static void writeStream(java.io.OutputStream outputStream)
After this method is called, output will be sent to outputStream, provided it is non-null. If outputStream is null, then this method has the same effect as calling writeStandardOutput(); that is, future output will be sent to the standard output stream.
-
writeStream
public static void writeStream(java.io.PrintWriter outputStream)
After this method is called, output will be sent to outputStream, provided it is non-null. If outputStream is null, then this method has the same effect as calling writeStandardOutput(); that is, future output will be sent to the standard output stream.
-
writeFile
public static void writeFile(java.lang.String fileName)
Opens a file with a specified name for output. If the file name is null, this has the same effect as calling writeStandardOutput(); that is, output will be sent to standard output. If an error occurs while trying to open the file, an exception of type IllegalArgumentException is thrown. If the file is opened successfully, then after this method is called, all of the output routines will write to the file, instead of to standard output. If an error occurs, the output destination is not changed.NOTE: Calling this method starts a GUI user interface thread, which can continue to run even if the thread that runs the main program ends. If you use this method in a non-GUI program, it might be necessary to call System.exit(0) at the end of the main() routine to shut down the Java virtual machine completely.
-
writeUserSelectedFile
public static boolean writeUserSelectedFile()
Puts a GUI file-selection dialog box on the screen in which the user can select an output file. If the user cancels the dialog instead of selecting a file, it is not considered an error, but the return value of the subroutine is false. If the user does select a file, but there is an error while trying to open the file, then an exception of type IllegalArgumentException is thrown. Finally, if the user selects a file and it is successfully opened, then the return value of the subroutine is true, and the output routines will write to the file, instead of to standard output. If the user cancels, or if an error occurs, then the current output destination is not changed.
-
getInputFileName
public static java.lang.String getInputFileName()
If TextIO is currently reading from a file, then the return value is the name of the file. If the class is reading from standard input or from a stream, then the return value is null.
-
getOutputFileName
public static java.lang.String getOutputFileName()
If TextIO is currently writing to a file, then the return value is the name of the file. If the class is writing to standard output or to a stream, then the return value is null.
-
put
public static void put(java.lang.Object x)
Write a single value to the current output destination, using the default format and no extra spaces. This method will handle any type of parameter, even one whose type is one of the primitive types.
-
put
public static void put(java.lang.Object x, int minChars)
Write a single value to the current output destination, using the default format and outputting at least minChars characters (with extra spaces added before the output value if necessary). This method will handle any type of parameter, even one whose type is one of the primitive types.- Parameters:
x
- The value to be output, which can be of any type.minChars
- The minimum number of characters to use for the output. If x requires fewer then this number of characters, then extra spaces are added to the front of x to bring the total up to minChars. If minChars is less than or equal to zero, then x will be printed in the minimum number of spaces possible.
-
putln
public static void putln(java.lang.Object x)
This is equivalent to put(x), followed by an end-of-line.
-
putln
public static void putln(java.lang.Object x, int minChars)
This is equivalent to put(x,minChars), followed by an end-of-line.
-
putln
public static void putln()
Write an end-of-line character to the current output destination.
-
putf
public static void putf(java.lang.String format, java.lang.Object... items)
Writes formatted output values to the current output destination. This method has the same function as System.out.printf(); the details of formatted output are not discussed here. The first parameter is a string that describes the format of the output. There can be any number of additional parameters; these specify the values to be output and can be of any type. This method will throw an IllegalArgumentException if the format string is null or if the format string is illegal for the values that are being output.
-
eoln
public static boolean eoln()
Test whether the next character in the current input source is an end-of-line. Note that this method does NOT skip whitespace before testing for end-of-line -- if you want to do that, call skipBlanks() first.
-
eof
public static boolean eof()
Test whether the next character in the current input source is an end-of-file. Note that this method does NOT skip whitespace before testing for end-of-line -- if you want to do that, call skipBlanks() or skipWhitespace() first.
-
getAnyChar
public static char getAnyChar()
Reads the next character from the current input source. The character can be a whitespace character; compare this to the getChar() method, which skips over whitespace and returns the next non-whitespace character. An end-of-line is always returned as the character '\n', even when the actual end-of-line in the input source is something else, such as '\r' or "\r\n". This method will throw an IllegalArgumentException if the input is at end-of-file (which will not ordinarily happen if reading from standard input).
-
peek
public static char peek()
Returns the next character in the current input source, without actually removing that character from the input. The character can be a whitespace character and can be the end-of-file character (specified by the constant TextIO.EOF).An end-of-line is always returned as the character '\n', even when the actual end-of-line in the input source is something else, such as '\r' or "\r\n". This method never causes an error.
-
skipBlanks
public static void skipBlanks()
Skips over any whitespace characters, except for end-of-lines. After this method is called, the next input character is either an end-of-line, an end-of-file, or a non-whitespace character. This method never causes an error. (Ordinarily, end-of-file is not possible when reading from standard input.)
-
getlnByte
public static byte getlnByte()
Skips whitespace characters and then reads a value of type byte from input, discarding the rest of the current line of input (including the next end-of-line character, if any). When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getlnShort
public static short getlnShort()
Skips whitespace characters and then reads a value of type short from input, discarding the rest of the current line of input (including the next end-of-line character, if any). When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getlnInt
public static int getlnInt()
Skips whitespace characters and then reads a value of type int from input, discarding the rest of the current line of input (including the next end-of-line character, if any). When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getlnLong
public static long getlnLong()
Skips whitespace characters and then reads a value of type long from input, discarding the rest of the current line of input (including the next end-of-line character, if any). When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getlnFloat
public static float getlnFloat()
Skips whitespace characters and then reads a value of type float from input, discarding the rest of the current line of input (including the next end-of-line character, if any). When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getlnDouble
public static double getlnDouble()
Skips whitespace characters and then reads a value of type double from input, discarding the rest of the current line of input (including the next end-of-line character, if any). When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getlnChar
public static char getlnChar()
Skips whitespace characters and then reads a value of type char from input, discarding the rest of the current line of input (including the next end-of-line character, if any). Note that the value that is returned will be a non-whitespace character; compare this with the getAnyChar() method. When using standard IO, this will not produce an error. In other cases, an error can occur if an end-of-file is encountered.
-
getlnBoolean
public static boolean getlnBoolean()
Skips whitespace characters and then reads a value of type boolean from input, discarding the rest of the current line of input (including the next end-of-line character, if any). When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.Legal inputs for a boolean input are: true, t, yes, y, 1, false, f, no, n, and 0; letters can be either upper case or lower case. One "word" of input is read, using the getWord() method, and it must be one of these; note that the "word" must be terminated by a whitespace character (or end-of-file).
-
getlnWord
public static java.lang.String getlnWord()
Skips whitespace characters and then reads one "word" from input, discarding the rest of the current line of input (including the next end-of-line character, if any). A word is defined as a sequence of non-whitespace characters (not just letters!). When using standard IO, this will not produce an error. In other cases, an IllegalArgumentException will be thrown if an end-of-file is encountered.
-
getlnString
public static java.lang.String getlnString()
This is identical to getln().
-
getln
public static java.lang.String getln()
Reads all the characters from the current input source, up to the next end-of-line. The end-of-line is read but is not included in the return value. Any other whitespace characters on the line are retained, even if they occur at the start of input. The return value will be an empty string if there are no characters before the end-of-line. When using standard IO, this will not produce an error. In other cases, an IllegalArgumentException will be thrown if an end-of-file is encountered.
-
getByte
public static byte getByte()
Skips whitespace characters and then reads a value of type byte from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getShort
public static short getShort()
Skips whitespace characters and then reads a value of type short from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getInt
public static int getInt()
Skips whitespace characters and then reads a value of type int from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getLong
public static long getLong()
Skips whitespace characters and then reads a value of type long from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getChar
public static char getChar()
Skips whitespace characters and then reads a single non-whitespace character from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error. In other cases, an IllegalArgumentException will be thrown if an end-of-file is encountered.
-
getFloat
public static float getFloat()
Skips whitespace characters and then reads a value of type float from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getDouble
public static double getDouble()
Skips whitespace characters and then reads a value of type double from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.
-
getWord
public static java.lang.String getWord()
Skips whitespace characters and then reads one "word" from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. A word is defined as a sequence of non-whitespace characters (not just letters!). When using standard IO, this will not produce an error. In other cases, an IllegalArgumentException will be thrown if an end-of-file is encountered.
-
getBoolean
public static boolean getBoolean()
Skips whitespace characters and then reads a value of type boolean from input. Any additional characters on the current line of input are retained, and will be read by the next input operation. When using standard IO, this will not produce an error; the user will be prompted repeatedly for input until a legal value is input. In other cases, an IllegalArgumentException will be thrown if a legal value is not found.Legal inputs for a boolean input are: true, t, yes, y, 1, false, f, no, n, and 0; letters can be either upper case or lower case. One "word" of input is read, using the getWord() method, and it must be one of these; note that the "word" must be terminated by a whitespace character (or end-of-file).
-
-


Search
Projects
Offers
Profile
Twoja wizytówka
Grażyna
Kowalska
Warsaw
,
Poland
Add interests
Add
Interest name1
name2
name3
interest name4
Add skills
Add
skill name1
name2
name3
skills name4
Personal Data
Password
Notifications
Fill the form with basic personal data
Name
Surname
Sex
Woman
Man
City
Email
Phone number
Save changes
Fill the form with extended personal data
Street
House number
Apartnent number
Post box
Save changes
Professions / Skills
Add
interest
interest
interest
Save changes
Change password
Enter password change and confirm with "Save"
Old password
New password
Change password
Job offers
Once a day
Weekly
I do not want to receive job offers
Comments on the statement
Immediately
Never
Only popular
Save changes


Tamagotchi Name:
Place of Birth:
Submit
Your pet was born in
!
Click for a gif!
Food Level:
Rest Level:
Play Level:
feed
nap
party


Creative Commons License Chooser has been helping creators to choose the most appropriate license for their work for a long time. As anything on the web, it needs updating. One of my mentors, Ari Madian, has created the new version of this chooser as part of his 2019 GSoC Project. As a 2019-2020 Outreachy intern, I will be working on making it production-ready. The goals of my internship include:
- Improving usability of the Chooser and making it easier for licensors to understand the process of selecting the most appropriate license.
- Setting up and automating internalization.
- Extracting License Chooser as a standalone npm package to make integrating Creative Commons licensing in other websites easier.
During the first two weeks of my internship I mainly worked on redesigning the license selection process based on the usability testing feedback. We decided to set up license selection as a step-by-step process of answering yes/no questions guiding a novice or somewhat experienced user to the CC license that best suits their needs.
Here is the first draft:
Features of this draft that stayed in current version:
- A card to show the information about currently selected license is prominent on the page.
- Four yes/no questions that help narrow the license choice.
What was changed in final version:
- The openness scale (which is drawn incorrectly, by the way) took up too much space on the first screen, not adding as much to the process.
- Toggles as an answer to yes/no questions are confusing for some users.
- Separate Personalization step was moved together with other steps.
- License attribution information was merged with the selected license card, because the card is supposed to contain all the information about selected license, including author/work url/ source url, if they are available.
Draft 2
As a result of continuous communication with my mentors, I this draft to be discussed at our weekly meeting.
Features that stayed in the current version:
- Two cards: one for the step-by-step process and the other for presenting license information.
- All the information about selected license in the second card.
- Personalization step as the last and optional step of choosing the license.
Features that were suggested during the meeting:
- License selection dropdown with all available licenses on the selected license card. This is for experienced users who know what license they want to choose and only need to add details, or copy the attribution text or html.
- A link to a page with more information on how to use the license when sharing on the selected license card: for users who need help with that.
Currently Final Draft :)
License Chooser Stepper Card
- Stepper Card shows five steps to selecting a license, one for each feature of CC licenses and an optional personalization step. The stepper icons show current selection status: selected/unselected features and current feature being displayed. Clicking on an icon opens the corresponding step.
- Each license feature has a yes/no question. A user clicks on a yes or no button to answer, and can immediately see what changed in the license, and the text beneath the buttons shows what current selection of the feature actually means. Default answer for each step besides the first one (attribution - 'BY') is 'no', so if a user simply clicks 'next' on each step, or clicks on the last step icon at the top, they get CC BY 4.0 license.
Selected License Card
- Current selection dropdown is for experienced users who can quickly select a license that they know they want to use. It also updates when a feature in the license selection process is changed.
- Selected license information displays information about the license and its clauses, as well as its icons. The wording of this part will probably change the most after discussion with the community and legal team.
- Attribution information for the license, with a choice between rich text or html code. These are displayed in tabs to save on space.
I created the wireframes in Figma, and I tried to integrate CC Vocabulary elements as much as possible.
Next steps for my project will include coding to update the license chooser Vue.js project, and iterating over the design based on community feedback.
You can follow my work at https://github.com/creativecommons/cc-chooser.


#496 ce_l
cecal
celestial
cell
centennial
centrifugal
centripetal
cereal
cerebral
cerebrospinal
ceremonial
cervical
cesspool


4 references to SearchingCmdlets
System.Management.Automation (4)
engine\CommandSearcher.cs (4)
117
_currentState = SearchState.
SearchingCmdlets
;
120
if (_currentState == SearchState.
SearchingCmdlets
)
815
_currentState = SearchState.
SearchingCmdlets
;
827
_currentState = SearchState.
SearchingCmdlets
;


Mail Order
For calculate total sold,please select -1 product
Press F5 or Refresh to load script again.