(function() {
function SongPlayer() {
var SongPlayer = {};
/**
* @desc Current song object
* @type {Object}
*/
var currentSong = null;
/**
* @desc Buzz object audio file
* @type {Object}
*/
var currentBuzzObject = null;
/**
* @function setSong
* @desc Stops currently playing song and loads new audio file as currentBuzzObject
* @param {Object} song
*/
var setSong = function(song) {
if (currentBuzzObject) {
currentBuzzObject.stop();
currentSong.playing = null;
}
currentBuzzObject = new buzz.sound(song.audioUrl, {
formats: ['mp3'],
preload: true
});
currentSong = song;
};
/**
* @function playSong
* @desc Plays audio file.
* @param {Object} song
*/
var playSong = function(song) {
currentBuzzObject.play();
song.playing = true;
};
SongPlayer.play = function(song) {
if (currentSong !== song) {
setSong(song);
playSong(song);
} else if (currentSong === song) {
if (currentBuzzObject.isPaused()) {
playSong(song);
}
}
};
SongPlayer.pause = function(song) {
currentBuzzObject.pause();
song.playing = false;
};
return SongPlayer;
}
angular
.module('blocJams')
.factory('SongPlayer', SongPlayer);
})();


{% extends 'index/base.html' %} {% block titleblock %}{% endblock %} {% block headerblock %}
{% endblock %} {% block mainblock %}If you have shopped with us before, please enter your details in the boxes below. If you are a new customer, please proceed to the Billing & Shipping section.
| Products | Total |
|---|---|
| {{ shoes.title }} × {{ shoes.add_nums }} | ￥{{ shoes.shoes_total_price }} |
| Total Amount | ￥{{ data.total_price }} |
Pay with cash upon delivery.
Make your payment directly into our bank account. Please use your Order ID as the payment reference. Your order will not be shipped until the funds have cleared in our account..
Please send a check to Store Name, Store Street, Store Town, Store State / County, Store Postcode.
Pay via PayPal; you can pay with your credit card if you don’t have a PayPal account.


What is it?
Extremely powerful neural net! It can identify 3 classes of images: cheese, milk and tomatoes! Sounds amazing, right?
Try it yourself!
Post the link into the field below (we support only jpg/jpeg images with .jpg ending):
{prediction}
{photos}
Who and why?
Who? Egor Gumin, Vladislav Evtushenko, Alex Scherbakhov.
Why? We just wanna have fun, you know.


Piggy Dice
Player One Name
Player Two Name
Play!
Roll
Hold
Current Dice Roll:
Turn Score:
Player 1:
Total Score:
Player 2:
Total Score:


To view the table of contents, click on the
Contents
tab in the left frame. The left frame's view will be changed to
display the table of contents. Click on a topic to have it displayed.
Use the
Previous Page
and
Next Page
buttons in the tool bar to navigate within the history of viewed
topics.
To print a help topic, select the topic in the left frame and press
the
Print
button in the tool bar.
To print multiple topics (or all) in one go, select
all desired topics in the left frame and click on the
Print
button. To select multiple topics, hold down the
Ctrl
(
Command
on Mac) key and click on the topic(s).
Please note that selecting a folder in the help
topic will not print all the sub-topics underneath it. Instead, you
should first expand the folder and select all sub-topics and then
press the
Print
button.
All screen shots used in this documentation are taken from Windows XP, using the XP look and feel. Please note that, depending on your operating system and the look and feel you are using, the screens may look different.


Better HAC
Student Selection
Choose your student
{% for user in users %}
{{ user['name'] }}
{% endfor %}
Add new student


[gecode-users] Generating constraints
Mikael Zayenz Lagerkvist
zayenz at gmail.com
Tue Oct 28 13:26:19 CET 2008
Hi,
If you have a tree representing an expression, then you should write a
tree-analyzer (a tree-walker for example) that posts constraints that
correspond to the tree. This is how the linear expressions in Gecodes
MiniModel works. For more information on writing tree analyzers, see a
compiler text as it corresponds to instruction selection.
There is no way to undo a tell - you have to copy the space.
Cheers,
Mikael
On Tue, Oct 28, 2008 at 12:58 PM, Max <chaosangel at gmx.de> wrote:
> Hello all,
>
> i currently try to post constraints and need your help.
> I have my constraints not in a textual format, but in a self made tree
> structure of the form
>
>
> rel">="
> / \
> op+ const=5
> / \
> var=x const=7
>
>
> (i hope this is readable)
>
> Now i want to generate and post a gecode constraint of it.
> Is there an easy way to recursivly define a constraint, because it seems
> to me that there is no baseclass or something that can be used.
>
> I wanted to to something of the form
>
> GeCodeConstraint recursive_converter(MyConstraint)
> {
> if "variable" return x;
> if "constant" return 5;
> if "op+" return recursive_converter(left_node) +
> recursive_converter(right_node);
> if "rel>=" return recursive_converter(left_node) >=
> recursive_converter(right_node);
> }
>
>
> I i found for GeCodeConstraint was MiniModel::LinRel<>, is there
> something more uniform, because i want to use boolean and integer
> variables (reified constraints) and stuff.
> (the arithmetic functions seem very generic returning a variable, but
> then a lot of extra variables would have to be generated)
>
>
> Any ideas ?
>
> 2nd question:
>
> Is there a way to post the value of a variable not in form of a
> constraint, so "branch" on a boolean variable but being able to undo it so
>
> so
> b[0].set(0);
> //after some time
> b[0].set(1);
>
> without copying the whole space?
>
> Thank you a lot.
>
> Max
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
>
--
Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/
More information about the gecode-users
mailing list


---
layout: single
author_profile: false
author: mark
title: "Submit Your Bach Bracket Picks"
permalink: /bachelor-submit-s19/
---
Drag the contestants in the order you think they will be told "thanks but no thanks".
- Top of the list = contestant who makes it to the end
- Bottom of the list = contestant you think will go home first
Good luck!
($10 USD / entry. Entries are due no later than Monday June 4 @ 8PM PST/EST)
{% include form-drag-sort.html %}
{% include gsheet.html %}


HTTP support
Similarly to OSC, several Faust architectures also provide HTTP support. This allows Faust applications to be remotely controlled from any Web browser using specific URLs. Moreover OSC and HTTPD can be freely combined.
While OSC support is installed by default when Faust is build, this is not the case for HTTP. That's because it depends on GNU libmicrohttpd library which is usually not installed by default on the system. An additional make httpd step is therefore required when compiling and installing Faust:
make httpd
make
sudo make install
Note that make httpd will fail if libmicrohttpd is not available on the system.
The HTTP support can be activated using the -httpd option when building the audio application with the appropriate faust2xxx command. The following table (table tab:httparch) lists Faust's architectures which provide HTTP support.
A simple example
To illustrate how HTTP support works let's reuse our previous mix4.dsp example, a very simplified monophonic audio mixer with 4 inputs and one output. For each input we have a mute button and a level slider:
input(v) = vgroup("input %v", *(1-checkbox("mute"))
: *(vslider("level", 0, 0, 1, 0.01)));
process = hgroup("mixer", par(i, 4, input(i)) :> _);
We are going to compile this example as a standalone Jack QT application with HTTP support using the command:
faust2jaqt -httpd mix4.dsp
Th effect of the -httpd is to embed a small Web server into the application, which purpose is to serve an HTML page representing its user interface. This page makes use of JavaScript and SVG and is quite similar to the native QT interface.
When we start the application from the command line:
./mix4
we get various information on the standard output, including:
Faust httpd server version 0.72 is running on TCP port 5510
As we can see the embedded Web server is running by default on TCP port 5510. The entry point is http://localhost:5510. It can be open from any recent browser and it produces the page reproduced figure fig:mix4-http.
JSON description of the user interface
The communication between the application and the Web browser is based on several underlying URLs. The first one is http://localhost:5510/JSON that return a json description of the user interface of the application. This json description is used internally by the JavaScript code to build the graphical user interface. Here is (part of) the json returned by mix4:
{
"name": "mix4",
"address": "YannAir.local",
"port": "5511",
"ui": [
{
"type": "hgroup",
"label": "mixer",
"items": [
{
"type": "vgroup",
"label": "input_0",
"items": [
{
"type": "vslider",
"label": "level",
"address": "/mixer/input_0/level",
"init": "0", "min": "0", "max": "1",
"step": "0.01"
},
{
"type": "checkbox",
"label": "mute",
"address": "/mixer/input_0/mute",
"init": "0", "min": "0", "max": "0",
"step": "0"
}
]
},
...
]
}
]
Quering the state of the application
Each widget has a unique "address" field that can be used to query its value. In our example here the level of the input 0 has the address /mixer/input_0/level. The address can be used to forge an URL to get the value of the widget: http://localhost:5510/mixer/input_0/level, resulting in:
/mixer/input_0/level 0.00000
Multiple widgets can be query at once by using an address higher in the hierarchy. For example to get the values of the level and the mute state of input 0 we use http://localhost:5510/mixer/input_0, resulting in:
/mixer/input_0/level 0.00000
/mixer/input_0/mute 0.00000
To get the all the values at once we simply use http://localhost:5510/mixer, resulting in:
/mixer/input_0/level 0.00000
/mixer/input_0/mute 0.00000
/mixer/input_1/level 0.00000
/mixer/input_1/mute 0.00000
/mixer/input_2/level 0.00000
/mixer/input_2/mute 0.00000
/mixer/input_3/level 0.00000
/mixer/input_3/mute 0.00000
Changing the value of a widget
Let's say that we want to mute input 1 of our mixer. We can use for that purpose the URL http://localhost:5510/mixer/input_1/mute?value=1 obtained by concatenating ?value=1 at the end of the widget URL.
All widgets can be controlled similarly. For example http://localhost:5510/mixer/input_3/level?value=0.7 will sets the input 3 level to 0.7.
Proxy control access to the Web server
A control application may want to access and control the running DSP using its Web server, but without using the delivered HTML page in a browser. Since the complete json can be retrieved, control applications can purely be developed in C/C++, then build a proxy version of the use interface, and set and get parameters using HTTP requests.
This mode can be started dynamically using the _ -server URL _ parameter. Assuming an application with HTTP support is running remotely on the given URL, the control application will fetch its json description, use it to dynamically build the user interface, and allow to access the remote parameters.
HTTP cheat sheet
Here is a summary of the various URLs used to interact with the application's Web server.
Default ports
| 5510 | default TCP port used by the application's Web server |
| 5511... | alternative TCP ports |
Command line options
| -port | set the TCP port number used by the application's Web server |
| -server | start a proxy control application accessing the remote application running on the given URL |
URLs
| http://host:port | the base URL to be used in proxy control access mode |
| http://host:port/JSON | get a json description of the user interface |
| http://host:port/address | get the value of a widget or a group of widgets |
| http://host:port/address?value=v | set the value of a widget to |
JSON
\subsubsection*{Top level} The json describes the name, host and port of the application and a hierarchy of user interface items:
{
"name": <name>,
"address": <host>,
"port": <port>,
"ui": [ <item> ]
An
\subsubsection*{Groups} A group is essentially a list of items with a specific layout:
{
"type": <type>,
"label": <label>,
"items": [ <item>, <item>,...]
The
\subsubsection*{Widgets}
{
"type": <type>,
"label": <label>,
"address": <address>,
"meta": [ { "key": "value"},... ],
"init": <num>,
"min": <num>,
"max": <num>,
"step": <num>
},
Widgets are the basic items of the user interface. They can be of different


{% include fancybox.html %} {% include disqus.html %} {% include google_analytics.html %} {% include custom/after_footer.html %}


This document introduces CIMPLE 2.0.18 and explains what has changed since the last public release (CIMPLE 2.0.16). If you are unfamiliar with the major changes introduced by CIMPLE 2.0.16, you might want to review them on the cimplewbem web site.
This was done because we specifically included new functionality in this release.
NOTE: This release note covers only the version 2.0.18 release.
The next chapter describes what is new in this release. Chapter 3 discusses bugs fixed by this release. Chapter 4 explains how to migrate providers developed with earlier versions.
This chapter covers new capabilities introduced by CIMPLE 2.0.18. Note that the release notes were not originally attached to the 2.0.0 release but were available with the 2.0.6 update to this release.
Note also that release notes were not consistently relese for versions between 2.0.6 and 2.0.16. This note covers changes made specifically between 2.0.16 and 2.0.18.
The following new functionality has been implemented:
1. Increased control of logging through both runtime and compile time parameters
2. Addition of tracing for the adapters with implementation of this in the Pegasus adapter.
3. Addition of class to control dynamic configuration of CIMPLE providers from the providers themselves.
In addition there have been:
1. Extensions to test providers and unit tests. 2. Correction of some issues in the provider adapters, primarily the Pegasus adapter.
As the requirement for logging provider information moves from development to production releases of providers, more control over logging was requested.
This version implements:
1. a compile configuration parameter to compile of the log macros defined in the log.h file (CIMPLE_FATAL, CIMPLE_ERR, CIMPLE_WARN, CIMPLE_INFO, and CIMPLE_DBG. if the configure flag —–disable_log_macros is set all of these macros are completely disable. Note that direct calls to the log and vlog functions in log.h are NOT disabled but we encourage users to implement logging through the macros.
2. Extension of logging to allow the user to set maximum size limits on the output log file and to create a backup file each time this limit is reached. In addition, the capability exists to limit the number of backup files.
The runtime parameters to control log file size and number of backups are
MAX_LOG_FILE_SIZE=<integer> where integer is the approximate number of bytes in the log file before it is rolled over into an archive file. If this <integer> is set to zero, the log file is considered to be unlimited (i.e. the same behavior as earlier versions of CIMPLE). If this parameter is not included in the .cimplerc config file it is assumed to be zero(0).
MAX_LOG_BACKUP_FILES=<integer> where <integer> is between 0 and 9. This defines the maximum number of backup files that will be maintained. Each time the log messages file is rolled over it is renamed messages.1 and all existing archived files are incremented by one (i.e. the existing messages.1 becomes messages.2). The oldest file is removed if its archive number is greater than the value of MAX_LOG_BACKUP_FILEs
There is a special behavior if MAX_LOG_BACKUP_FILES =0. In this case, the log file is simple removed and restarted.
3. Addition of a runtime control for log output with a new runtime configuration parameter.
ENABLE_LOGGING="true" | "false" This runtime configuration variable absolutely controls the output of log files. If set to false, all logging is turned off.
A new class has been added to CIMPLE to allow providers to dynamically control at least some of the runtime configuration parameters from the provider iteself. Today this includes the following functions ad defined in src/cimple/CimpleConfig.h:
Set the log level to the level defined by the input level param level String parameter that defines log level. Must be one of the predefined constants —return true if set correctly Else false
static bool setLogLevel(String& level);
Set the log level to the level defined by the enum variable input —param level - Level to set —return bool true if operation executed.
static bool setLogLevel(Log_Level level);
Get the current log level —return Log_Level
static Log_Level getLogLevel();
Get the String that defines the current log level (i.e. DBG, WARN, etc.) —return String that defines the current log level
static const char getLogLevelString();
Set the HOME environment variable that defines the location of the various files used by CIMPLE. There is no corresponding get method. —param env_var —return bool true if accepted
static bool setHomeEnv(const charenv_var);
Set the maximum size in bytes of the log file before it is pruned and a new file started. —param newSize uint32 variable that defines the maximum size in bytes. If zero (0) the size is unlimited. This is the default unless the log size varaible is set either by this method or the CIMPLE config file. —return bool Returns true if the input is accepted.
static bool setLogFileMaxSize(uint32 newSize);
Get the value of the variable that defines the maximum size of the log file. —return uint32 - value of the maximum File size variable.
static uint32 getLogFileMaxSize();
Set the internal variable that controls the maximum number of log files that CIMPLE will maintain. If the logFileMaxSize is set to a non-zero value, each time the log file reaches that size, it is closed, the name changed and a new log file started. This variable controls the maximum number of backup log files maintained. When this limit is reached, old files will be deleted. If the current value set by this variable is zero (0) no old files will be maintained and the current file will be deleted when it reaches the maximum size. Zero is the default value for the variable if it is not set by this method or the CIMPLE config file. The backup log files are numbered messages.n where n is the number of backup file, 1 being the newest. —param number uint32 integer between 0 and 9 that defines maximum number of backup files to be maintained. —return bool Returns true if the method is accepted. NOTE: Maximum number of backup files is 9. Also there is a cost to keeping many files because of the renaming process.
static bool setLogMaxBackupFiles(uint32 number);
Get the current value for the variable that controls the maximum number of log files maintained —return uint32
static uint32 getLogMaxBackupFiles();
Set the logging enabled state to either true or false. When the logging state is true, logging is enabled. Otherwise it is completely disabled. The default before being set by either this method or the CIMPLE configuration files is true. —param netState Boolean defining the new state —return bool
static bool setLogEnabledState(bool netState);
Get current logEnabledState —return bool Returns the current state
static bool getLogEnabledState();
Forces a reread of the CIMPLE configuration file. Normally this is for testing only.
static void readConfig();
Remove Log files. Cleans and restarts the log files. This removes any log backup files also. Use this ONLY if you want to completely delete log files. Removes all files in the log directory with the logfile name. —return true if operation successfully executed. False indicates some error in trying to remove files.
static bool removeLogFiles();
Enable or Disable the logging calls from log macros. This corresponds to the ENABLELOGGING runtime configure parameter in .cimplerc —param newState - The state to which this variable is to be set. If false, logging is immediatly disabled (no more log entries are generated) —return bool defining the previous state before newState is set into the variable
static bool setEnableLoggingState(bool newState);
Get the current state of the enable logging variable. —return true if logging enabled.
static bool getEnableLoggingState();
NOTE: Please consider this class experimental for this version as it is the first release of this interface.
Created a generalized tracing capability (that uses the log for output) for the adapters. In the past, there was very little tracing capability for the Pegasus adapter and today the cmpi adapter has tracing permanently integrated and activated.
With this capability tracing can be controlled at the compile level with the configuration parameter –enable-adapter-trace which will enable compile of tracing statements.
When activated, tracing outputs trace statements from the defined adapter to the log file.
Activation of this capability is a compile time options with the –enable-adapter-trace option to configure and configure.bat. This retains the original behavior of disable tracing/logging of adapters with no option set for the Pegasus (C++) provider. The CMPI provider adapter retains its current and is not controlled through this configuration parameter today.
For this release only the Pegasus adapter has been modified for this capability and control is somewhat limited since it uses the same runtime parameters as logging with all tracing controlled through the severity option (all adapter traces are at the level LL_DBG). This will be extended in future releases to further separate adapter traces from provider tracing.
It is expected that adapter tracing will be primarily used in development and can be compiled off in release mode.
In addition functions have been added for both the cmpi and pegasus adapters to be able to print or log all the information in cmpi or pegasus instances as they pass through the adapters. Note that these functions have not been fully implemented in the providers themselves but that the functions exist with limited usage in the Pegasus provider.
Addition of a common parameter for genclass, genprov, genmod, genproj to allow the class list to be provided via a file input. This was provided because on windows at least, some users were reaching the limit of the cmd buffer with single command line inputs to these utilities.
The new option is -F <filename> where filename is the name of a file that contains the list of classes one class per line.
The original functionality using -f as an option in genclass has been maintained also for backward compatibilty.
This release fixes the bugs described below (all critical bugs were addressed by earlier maintenance releases).
See the ChangeLog and version diff file for more information about bug fixes.
Always regenerate classes, providers, and modules when using a new version
of CIMPLE. This is a trivial matter of running genrpoj
as follows:
$ genproj MODULE-NAME CLASS-1 CLASS-2 ... CLASS-N
This regenerates the classes and module and will patch your providers if necessary. This operation will not require any rework on your part. Just regnerate, clean, and remake.
CIMPLE 2.0.18 supports the following platforms.


| Package | Description |
|---|---|
| <Unnamed> |
This package provides some examples of how to use Object Selector and JUnit tests.
|
| de.linearbits.objectselector |
This package provides the public API for Object Selector.
|
| de.linearbits.objectselector.ops |
This package provides abstract base classes for different types of operators used
internally by the selector
|
| de.linearbits.objectselector.util |
This package provides utility classes that implement accessors for different types of objects, including:
|
| Modifier and Type | Class and Description |
|---|---|
class |
ElementAccessor
An accessor for the Element class
|
| Constructor and Description |
|---|
SelectorBuilder(IAccessor<T> accessor)
Creates a new selector
|
SelectorBuilder(IAccessor<T> accessor,
java.lang.String query)
Creates a new selector with the given schema and the given query
|
| Constructor and Description |
|---|
BinaryOperator(IAccessor<T> accessor,
java.lang.String label)
Constructor
|
ParenthesisOperator(IAccessor<T> accessor,
boolean begin)
Constructor
|
UnaryOperator(IAccessor<T> accessor,
java.lang.String context,
java.lang.String label)
Constructor
|
| Modifier and Type | Class and Description |
|---|---|
class |
ArrayAccessor<T>
An accessor array data elements
|
class |
BooleanArrayAccessor
An accessor arrays of booleans
|
class |
CharArrayAccessor
An accessor arrays of chars
|
class |
DoubleArrayAccessor
An accessor arrays of doubles
|
class |
FloatArrayAccessor
An accessor arrays of floats
|
class |
IntArrayAccessor
An accessor arrays of ints
|
class |
ListAccessor<T>
An accessor for list data elements
|
class |
MapAccessor<T>
An accessor for map data elements
|
class |
ObjectAccessor<T>
An accessor for object data elements
|
class |
PrimitiveArrayAccessor<T>
An accessor arrays of primitives
|
class |
ShortArrayAccessor
An accessor arrays of shorts
|


#assign message = "
An error has occurred.
For detailed error information, please see the HTML source code, and contact the forum Administrator.
" + message + "


@(t: lila.team.Team, userIds: List[String])(implicit ctx: Context) @title = @{ "Kick from Team " + t.name } @team.layout(title = title) {
Who do you want to kick out of the team?


The Google Analytics Embed API is a JavaScript library that allows you to easily create and embed a dashboard on a third-party website in a matter of minutes. It gives you a set of pluggable components that can work together to build complex tools, making it both simple and powerful at the same time.
The demos on this site showcase many of the things that are possible with the Embed API. Each demo builds on top of ideas presented in the previous one, so you should check them out in order.
{{ pg.excerpt | striptags }}
Code samples are included to help you get started, but feel free to view the page source or check out the code on Github.


Clause 20 of the Standard contains the General utilities library, lib.utilities. This library describes components used by other library elements, such as a predefined storage allocator for dynamic storage management. If you are reading this manual online, click the name of header file or entry to go to its description.
| Header File | Corresponding Entries in this Reference | |
<utility> |
||
<functional> |
||
<memory> |


Merch Booth is broken.
Please tell the streamer to fix their Merch Booth config settings.
Have a nice day.


PhoneGap is the open source framework that gets you building amazing mobile apps using web technology
We created this approach to authoring apps because we’re web developers at ❤, and wanted to remove the complexity of writing an app in multiple languages (like Objective C and Java) for all of the relevant mobile platforms. With PhoneGap you build beautiful cross-platform apps using HTML, CSS and Javascript.
Rapid development = better apps
For web developers with a history of creating outstanding user experiences and products, PhoneGap is the tool to use to quickly transfer web development skills into making awesome mobile apps. Leverage the web technologies that you know and love to make more time for rapid iterations and releases. By releasing your mobile app early and often, and gathering metrics for quick iterations, your customers get what they want and need.
Cross platform = greater reach
There is nothing worse than making your hugely anticipated/successful/helpful mobile app only available for a single platform. It means missing out on a huge part of your potential customer base. By using PhoneGap you can create an app for each of the platforms that you choose, using a single code base. Focus on creating a great experience for all of your potential customers instead of authoring complex platform compatibility layers — it just makes sense.
Native APIs = native functionality
Developing your mobile app using HTML, CSS and Javascript doesn’t mean that you have to give up on native functionality that makes mobile devices so extraordinary. PhoneGap gives you access to all of the native device APIs (like camera, GPS, accelerometer and more), so that the app you build with web tech behaves just like a native app. It’s pretty cool.
Open source = great community
By remaining free and open source, PhoneGap makes mobile app development accessible to thousands of web developers. We have great community support, which means that there are more people available to help you out and to keep the software current and robust. The Adobe PhoneGap team remains highly active in the stewardship and development of the Apache Cordova project.
PhoneGap vs. Apache Cordova
We’re often asked “What is difference is between PhoneGap and Cordova?”. Apache Cordova was born from PhoneGap. In 2011, the PhoneGap codebase was donated to Apache for incubation, and the project has continued to thrive ever since. Apache Cordova is still the engine that powers PhoneGap, much like WebKit is the engine that powers many modern web browsers.
It’s the robust tools that sets PhoneGap apart, including:
our command line interface, the PhoneGap Desktop app, the PhoneGap Developer app, and PhoneGap Build.
PhoneGap CLI
The PhoneGap CLI is the most powerful and flexible way to use PhoneGap. Built on top of Apache Cordova, you can create, serve, compile, and run apps from the comfort of your command-line terminal. Written in Node.js and distributed on npm, you can use the CLI on any platform and integrate it into any web development workflow. Whether developing locally or running a continuous integration server, the PhoneGap CLI will meet your needs.

Read the DocsDesktop App
PhoneGap Desktop is the simplest way to get started using PhoneGap. You use it to create apps, and serve those apps to connected mobile devices. It is the alternative to using the CLI, using the same libraries under the hood. So no need to memorize commands or install dependencies - those are all included when you download PhoneGap Desktop.
If you prefer to use a GUI, then PhoneGap Desktop is for you.
Developer Mobile App
We created the PhoneGap Developer mobile app so that you can quickly see how your mobile app looks and works. Develop locally then instantly see changes on your connected mobile device - without the need to re-sign, re-compile, or reinstall your app to test your code. By testing your PhoneGap app on a mobile device, you get access to device APIs that aren’t available in web browsers.
PhoneGap Developer gives you the confidence that your app will work as you intend on the devices that you are targeting.
Due to Apple guidelines, the PhoneGap Developer App has been removed from the iOS App Store. New users will be unable to download. No impact to Android or Windows versions.
-
From Google Play
-
From The Windows Store
PhoneGap Build
Take the pain of compiling out of mobile app development - simply upload your HTML, CSS and Javascript assets to PhoneGap Build and we’ll package them for you. Get app-store ready apps without the headache of maintaining native SDKs. We do the work for you in the cloud and your app will always be built with the most up-to-date SDK for the platform you are targeting.
Package your mobile apps in the cloud with PhoneGap Build.


Home
logout
Type
Select
Double Decker
Single Decker
Mini Bus
Micro Bus
Ambulance
Picup
Device ID
Capacity
Maker
Vehicle Number
Chesis Number
Engine Number
Make year
Fitness Deadline
AC/Non-AC
AC
Non-AC
Image
Submit


a6c
|
||||||
|
|
|
674
22 1000
16-bit ApplicationsAlthough 16-bit applications will run on Windows NT, they lack the efficiency and robustness of 32-bit native applications. If possible, migrate your applications to 32-bit NT applications rather than using 16-bit Windows or DOS applications. Newer 32-bit applications are portable between Windows NT and Windows 95. I/O PerformanceI/O performance is not usually an issue for the client machine. The typical application is loaded into memory and does not use the I/O subsystem unless swapping is occurring. If your machine is swapping, performance is severely degraded and faster I/O will not significantly help.
Microsoft Windows 3.1 and Windows for Workgroups 3.11Microsoft Windows 3.1 and Windows for Workgroups 3.11 have been in production for quite some time. Microsoft Windows is currently the most popular graphical operating environment. Although Microsoft Windows is a very good operating system for home use, I recommend that you use Windows for Workgroups if you are running in a networked environment. Windows for Workgroups provides better networking than Microsoft Windows. Windows for Workgroups also provides better 32-bit support than Microsoft Windows 3.1. MemoryAs with Windows NT, the major concern with the Windows or Windows for Workgroups client is the lack of memory. Because Windows and Windows for Workgroups are both virtual-memory systems, it is possible to run much larger applications than will fit in memory. Although this is possible, it causes swapping, which degrades performance. Unlike Windows NT and Windows 95, the Windows and Windows for Workgroups operating systems do not come with a performance monitoring tool that shows you when you have run out of memory. One way you can determine your memory usage under Windows 3.1 or Windows for Workgroups is to invoke a DOS shell and run the MEM command. The MEM command shows how much of your memory is currently in use. NetworkAnother way to reduce excess memory usage is to reduce the number of network protocols currently loaded. Only load those protocols you plan to use. By reducing the number of excess protocols, you reduce the need for memory and CPU usage.
Microsoft Windows 95The recently introduced Microsoft Windows 95 greatly improves the Windows operating system. Windows 95 includes integrated 32-bit support, built-in networking, and other optimizations. If you currently run on Windows 3.1 or Windows for Workgroups, seriously think about upgrading to Windows 95 or Windows NT. Windows 95 is robust and performs well but, like Windows NT, has an appetite for memory. Unless you have 12M or 16M of RAM, do not consider Windows 95. If you have the resources, there are many great features of Windows 95 that can help you optimize your system as an Oracle client:
The system monitor and integrated network subsystem features can substantially improve your optimization efforts. However, you must have enough system memory to run Windows 95. 32-Bit SupportWindows 95 is a 32-bit operating system that can run 16-bit applications. Even though it is possible to run 16-bit applications, doing so is not recommended. To take full advantage of Windows 95, you should run only 32-bit applications. Oracle provides 32-bit support for Windows 95 that has been optimized for the operating environment. By taking advantage of the 32-bit support feature, you can improve performance. MemoryWith Windows 95 as with every OS, you must reduce unnecessary memory usage so that you can allocate as many resources as possible to the application. By reducing or removing any nonessential overhead from the system, you can increase the amount of memory available for the application. You must ensure that you have sufficient memory to run your applications effectively. NetworkBy removing any unnecessary network clients, protocols, and services from the system, you reduce overhead. Running unnecessary network functions can increase CPU and memory overhead. With the Windows 95 network configuration utility, you can easily reduce these functions to the minimum required for your system. Oracle SupportOracle has recently provided native support for Windows 95. Use the Windows 95 version of SQL*Net to improve your applications performance. With native support for Windows 95, Oracle can take advantage of OS features and 32-bit support to optimize the product.
|
|


Welcome to the Coding Quiz Challenge! Your objective is to answer the following questions as quickly as possible. However, answer incorrectly and your score as well as the time remaining will be affected. Are you up to the challenge? Click the 'Start Quiz' button to begin. Good luck, challenger!
Your final score is .
Enter initials:


System features
4.1 Functional Requirement
ID: PFR1
TITLE: Sign Up
ACTOR: User
PURPOSE: Register the user information
OVERVIEW: Given that a user has downloaded the mobile application, or accessed the website then the user should be able to register into the system. The user must provide Name, Password, Address, Phone Number, address .
TYPE: Primary function
PRIORITY: High
DEP: none
COURSE OF EVENTS:
-
Open the application or website
-
Enter all the information
-
Click on register
ALTERNATIVE COURSE OF EVENTS:
-
Email not match with regex, show error: “Please provide a valid email
-
Password is less than 6 digits, show error: “Password must include at least 6 digits
-
Any field left blank, show error: “All the fields must be filled up
4.1.1 Functional Requirement
ID: PFR2
TITLE: Sign up with( Facebook, Google)
ACTOR: User
PURPOSE: Register the user information
COURSE OF EVENTS:
I) Open the application or website
II) Enter all the information
III) Click on register
ALTERNATIVE COURSE OF EVENTS:
I) Email not match with regex, show error: “Please provide a valid email”
II) Password does not match: “Password or email is not correct. Please retry!”
III) Any field left blank, show error: “All the fields must be filled up”
4.1.2 Functional requirement 1.2
ID: PFR3
TITLE: Sign in
ACTOR: User
PURPOSE: Login the user
OVERVIEW: Given that the user is already registered, the user will be able to login by providing the email and password.
TYPE: Primary function
PRIORITY: High
DEP: PFR1
COURSE OF EVENTS:
I) Select “Already Registered” button from the registration page.
II) Enter email and password
III) Click on sign in
ALTERNATIVE COURSE OF EVENTS:
I) Email not exist, show error: “This email is not registered yet. Please Register first.”
II) Password does not match: “Password or email is not correct. Please retry!”
III) Any field left blank, show error: “All the fields must be filled up”
4.1.3 Functional requirement 1.3
ID: PFR4
TITLE: Search
ACTOR: User
PURPOSE: Search for packages to buy
OVERVIEW: From the home page the user must be able to search for their preferred packages. The search will find the match the title of the package. The user will also be able to add tags to shorten their search range.
TYPE: Primary function
PRIORITY: Medium
DEP: PFR2
COURSE OF EVENTS:
I) Type the search keywords
II) Provide Tags (Optional)
III) Click on search
ALTERNATIVE COURSE OF EVENTS:
I) Search keywords are empty, show error: “Please enter a keyword”
4.1.4 Functional requirement 1.4
ID: PFR5
TITLE: Select Package
ACTOR: User
PURPOSE: Book the package
OVERVIEW: From the packages page a user will be able to click on place order. The order will be placed assuming that the payment type will be pay on delivery and address will be the address of the user.
TYPE: Primary function
PRIORITY: High
DEP: PFR2
COURSE OF EVENTS:
I) Click on Select Package
II) Click confirm booking or Cancel.
ALTERNATIVE COURSE OF EVENTS:
I) Address must be valid, Admins will check for the validity of the address and manually send SMS to the user regarding the issue
4.1.5 Functional requirement 1.5
ID: PFR5
TITLE: Rate Package
ACTOR: User
PURPOSE: Rate and Review previously bought package.
OVERVIEW: From the Packages page the user can click on “Review packages” button. This will pop up a window with 5 empty stars and a comment box. The user will have to click on any star which will signify the rating based on one’s index of the star. The user can additionally add a review comment into the box and submit the rating.
TYPE: Primary function
PRIORITY: Low
DEP: PFR2
COURSE OF EVENTS:
I) Select a star
II) Optionally type a comment
III) Click on submit
ALTERNATIVE COURSE OF EVENTS:
I) No stars selected, show error: “You must rate the product from 1-5”
4.1.6 Functional requirement 1.6
ID: PFR6
TITLE: Chat with us – Mobile Application only
ACTOR: User
PURPOSE: Conversation through messages for the packages in real time with chat bot.
OVERVIEW: From the Packages page the user can chat for the suitable packages. This bring the user to a Bot., where the bot reply the user most appropriate answer.
PRIORITY: High
DEP: PFR8
COURSE OF EVENTS:
I) Select Chat with us from home page
II) Click on close chat
ALTERNATIVE COURSE OF EVENTS:
I) Data not downloaded properly, show error: “Couldn’t connect to server, please check your internet connection and try again later!”
II) Wait till the environment changes.
4.1.7 Functional requirement 1.7
ID: PFR7
TITLE: Profile Page
ACTOR: User
PURPOSE: View the profile page
OVERVIEW: Show the user information to the user. This information will include, name, email, phone number, address and user type. User will be able to modify any of this information except for the mail.
TYPE: Primary function
PRIORITY: Low
DEP: PFR2
COURSE OF EVENTS:
I) Select Profile button from home
II) Select any field
III) Modify the selected field
IV) Click on update information
ALTERNATIVE COURSE OF EVENTS:
I) Data not downloaded properly, show error: “Couldn’t connect to server, please check your internet connection and try again later!”
-Wait till environment changes.
4.1.8 Functional requirement 1.8
ID: PFR8
TITLE: Packages Page
ACTOR: User
PURPOSE: View the Packages page
OVERVIEW: Packages page can be accessed from various other views. It is assumed that this page is accessed by clicking on a package. The information regarding that package will then be shown here. User can view the details of a package from this view.
TYPE: Primary function
PRIORITY: High
DEP: none
COURSE OF EVENTS:
I) Select a package
II) Select any functionality provided by the package page
ALTERNATIVE COURSE OF EVENTS:
I) Package details not downloaded in time limit of 30 seconds, show error: “Couldn’t connect to server, please check your internet connection and try again later!”
-Appear retry button
4.1.9 Functional requirement 1.9
ID: PFR9
TITLE: Administrator Login
ACTOR: Admin
PURPOSE: Login the admin
OVERVIEW: Given that the admin is already registered the admin will be able to login in trough a web portal.
TYPE: Primary function
PRIORITY: High
DEP: none
COURSE OF EVENTS:
II) Enter email/username and password
III) Click on sign in
ALTERNATIVE COURSE OF EVENTS:
I) Email not exist, show error: “This email/user is not registered yet. Please Register first.”
II) Password does not match: “Password or email is not correct. Please retry!”
III) Any field left blank, show error: “All the fields must be filled up”
4.1.10 Functional requirement 1.10
ID: PFR10
TITLE: Admin Dashboard
ACTOR: Admin
PURPOSE: View the admin dashboard
OVERVIEW: The admin dashboard will show sales overview and analytics, recent activity and latest orders.
TYPE: Primary function
PRIORITY: High
DEP: PFR9
COURSE OF EVENTS:
I) Change booking status
II) View booking details
ALTERNATIVE COURSE OF EVENTS:
I) No booking to view
4.1.11 Functional requirement 1.11
ID: PFR12
TITLE: Packages Menu
ACTOR: Admin
PURPOSE: Add new, remove or edit existing packages
OVERVIEW: The admin will be able to create a new package. S/He will also be able to remove or edit existing packages.
TYPE: Primary function
PRIORITY: High
DEP: PFR9, PFR10, PFR11
COURSE OF EVENTS:
I) Create a new Package
III)Remove existing Package
III) Add package description
ALTERNATIVE COURSE OF EVENTS:
I) No package to edit/delete
II) Package capacity reached: “no more packages can be added!”.
4.2 Functional requirement 2
ID: SFR1
TITLE: Download mobile application
ACTOR: User
OVERVIEW: A user should be able to download the mobile application through either an application store or similar service on the mobile phone. The application should be free to download.
PURPOSE: In order for a user to download the mobile application.
TYPE: Secondary function
Priority: High
DEP: None
COURSE OF EVENTS:
I) Downloads the app from google play store
4.2.2 Functional requirement 2.2
ID: SFR2
TITLE: Check Password
ACTOR: System
RAT: Match the password
DESC: Match password entered by the user during login. The inserted password will be matched against the one stored in the database.
TYPE: Secondary function
PRIORITY: High
DEP: PFR2
COURSE OF EVENTS:
I) Get password from user
II) Get password from databases
III) Match if both the passwords are the same.
ALTERNATIVE COURSE OF EVENTS:
I) The errors will be handled by the view using this function
4.2.3 Functional requirement 2.3
ID: SFR4
TITLE: Check if User is logged in
ACTOR: System
PURPOSE: Check if user is already logged in
OVERVIEW: The system may need to check if the user is properly logged in in different scenarios. The sign in state may be cached in the running device.
TYPE: Secondary function
PRIORITY: High
DEP: PFR2
COURSE OF EVENTS:
I) Get user sign in status from device
ALTERNATIVE COURSE OF EVENTS:
I) Couldn’t access device storage, show error “Couldn’t access device memory. Check the permissions for this app”
4.2.4 Functional requirement 2.4
ID: SFR3
TITLE: Chat with us
ACTOR: System
PURPOSE: Chat with a user through a chat bot
OVERVIEW: Detect the keyword of messages and then reply on basis of the words.
TYPE: Secondary function
PRIORITY: High
DEP: none
COURSE OF EVENTS:
I) Get messages
II) Detect the keyword
III) Reply the answer.
ALTERNATIVE COURSE OF EVENTS:
I) Internet Connection Problem, show error “Couldn’t load messages, please try again later”
-Appear retry button


DQA3機構測試管理系統123
Settings
Activity Log
Logout
Dashboard project
Dashboard unit
Test plan
System setting
Project
Phase
B Phase
C Phase
INV
Other
Search
Ready to Leave?
×
Select "Logout" below if you are ready to end your current session.
>


Why was Neofetch created?
10/04/2017 - Shell - Dylan Araps
Neofetch or as it was originally called fetch was never meant to be a replacement for Screenfetch nor was it ever meant to display Ascii logos. Neofetch first started as my 70 line hard-coded script that only supported Arch Linux, only displayed a tiny amount of info and only supported showing images with w3m-img.
I started posting screenshots of my system to /r/unixporn which included my tiny little script. People started using the script and started asking me to add support for their Linux Distros and later their Operating systems. Happy to see that others were using something that I created, I started adding support to various Distros and Operating systems.
Oldest screenshot of fetch
When it came to adding support for Mac OS I realized that I had hit a stopping point. The script wasn't written in a way that would allow me to easily expand it to more Operating systems; it needed a rewrite. So I (re)wrote the script from scratch over an entire weekend and the result is the script base/structure that Neofetch is still using today.
I continued to work on Neofetch every day and whenever someone suggested a feature, I would add it no questions asked. One day a user by the name of @aloisdg opened a bug report on the repo requesting "ascii art support". [1] I jumped on this and was shocked to see how easy it was to implement, I had a working version the same day and it was in master a day later.
Early distro ascii support
As I continued working on Neofetch every day, looking for ways to improve it I decided to get it to feature parity with Screenfetch. Once Neofetch supported displaying the same info as Screenfetch I thought to myself; what else can we add to Neofetch?
I started adding new info functions, features, config options and Neofetch eventually supported displaying info like Current Terminal Emulator, Terminal Emulator Font, Device Model (Name of laptop, etc.) and much more.
I continue to work on Neofetch every day and I'm still looking for ways to extend it further. :-)
[1] https://github.com/dylanaraps/neofetch/issues/28


--- layout: post title: Field trip on Saturday date: 2008-09-29 07:11:05.000000000 -05:00 type: post parent_id: '0' published: true password: '' status: publish categories: - English - Reflections - USA08 tags: [] meta: _edit_last: '1412221' author: login: dreamessenceonthemove email<EMAIL_ADDRESS>display_name: darribas first_name: Daniel last_name: Arribas-Bel permalink: "/2008/09/29/field-trip-on-saturday/" ---
| Arcosanti&Montezume Well field trip |
I´m sorry for being this absent, life is speeding up like hell at the university and I wanna keep up, there´re so many nice things happening to me on this side (work) of my life that I´m giving it some extra-time I´d usually devote to other tasks. This´what economists usually call investment :)


Keyword Input
Keywords are one of the primary ways to control Alfred, and the most commonly used input type for workflows. It can be used alone or followed by a query, telling Alfred to perform an action or search for the query that follows.
In this example, the search term "fitbit" shows me results for both the application installed on my Mac and for the workflow keyword that launches Fitbit in my Google Chrome browser.
How do I use keyword inputs?
Use keywords to create workflows that appear when you type your set keyword.
When creating a keyword, you can set a few parameters;
- Keyword: Set the word you want to type into Alfred to activate your workflow
- with space: Decide whether you require a space between your keyword and the query
- Argument: Is an argument required?

Using Variables in Keywords
As well as setting a fixed keyword, you can use Workflow variables to dynamically set a keyword for your workflow.
Workflow Examples Using a Keyword Input
"Should I watch this movie?" example workflow
A great way to see a keyword input in action so to take a look at the "Should I watch this movie?" example in Alfred's Workflow Examples in the Preferences.
The "movie" keyword is connected to three actions, and is set to require a keyword (the title of a movie).
Setting the argument to "optional" would allow the website to launch without a query, if you pressed the Return key without adding a query.
With the title and subtitle set above, Alfred presents this text until you've typed your query and he can show you search results.
"Fitbit in Chrome" workflow
You can download the Fitbit workflow shown in the first screenshot at the top of this page, for a very simple workflow where one keyword is connected to one "Open URL" action.


{% trans %} We're gearing up to present the final results at the Toronto International Film Festival. Get ready by watching our latest Early Entry Award winners. {% endtrans %}
{{ _('See the winning flicks') }}


|
$for(include-before)$
$include-before$
$endfor$
$for(include-after)$
$include-after$
$endfor$
$if(rsc-footer)$
$if(include-after)$
$endif$ This message was generated on $rsc-date-time$. This Version: $rsc-report-rendering-url$ If you wish to stop receiving emails for this document, you may unsubscribe here. If HTML documents are attached, they may not render correctly when viewed in some email clients. For a better experience, download HTML documents to disk before opening in a web browser. $endif$ |


Heatmaps in R
In every statistical analysis, the first thing one should do is try and visualise the data before any modeling. In microarray studies, a common visualisation is a heatmap of gene expression data. In this post I simulate some gene expression data and visualise it using the pheatmap
function from the pheatmap package in R
. You will also need the mvrnorm
function from the MASS library to simulate from a multivariate normal distribution, and the brewer.pal
function from the RColorBrewer library for easier customization of colors.
Components of a Heatmap
There are four main components that should be considered when drawing a heatmap:
Formatting the data
First I simulate some gene expression data, based on a function that I created, for genes which are correlated conditional on an exposure status (the function definition is given at the end of this post):
In order to properly label the heatmap, we must label the matrix of gene expressions:
Choosing the color scheme
To avoid wasting time choosing colors, I recommend using the RColorBrewer package based on the design of geographer Cynthia Brewer. From the RColorBrewer help page:
There are 3 types of palettes, sequential, diverging, and qualitative:
- Sequential palettes are suited to ordered data that progress from low to high. Lightness steps dominate the look of these schemes, with light colors for low data values to dark colors for high data values.
- Diverging palettes put equal emphasis on mid-range critical values and extremes at both ends of the data range. The critical class or break in the middle of the legend is emphasized with light colors and low and high extremes are emphasized with dark colors that have contrasting hues.
- Qualitative palettes do not imply magnitude differences between legend classes, and hues are used to create the primary visual differences between classes. Qualitative schemes are best suited to representing nominal or categorical data
To see the palettes available for coloring the heatmap:
You need to provide the RColorBrewer::brewer.pal
function with two arguments; the number of values (All the diverging palettes are available in variations from 3 different values up to 11 different values), and the name of the palette as shown in the figure above. We will use the Reds palette which has a maximum number of 9 colors:
Annotating the rows and/or columns
If the subjects can be contrasted, it is useful to display this information on the heatmap e.g. case/control status or exposed vs. unexposed. To do so, we first need to create a separate data frame which contains that information. This data frame can contain many columns or just one column. (Note that the rownames of this data frame need to correspond to the rownames i.e. Subjects IDs of the gene expression data created above). In this example we create a data frame which has exposure status and tumor type for each subject:
We also want to annotate information on the genes, such as pathway membership. To do so, we create another data frame which has the gene annotations. Note once again that the rownames of this data frame need to correspond to the columnames i.e. Gene IDs of the gene expression data created above.
Clustering
You need to decide if its important to cluster the rows and/or columns of your heatmap. If you decide to cluster, you must then choose the distance metric to use and the clustering method.
The pheatmap comes with lots of customizations (see the help page for a complete list of options). In this example I only want to cluster the genes (i.e. the rows), and place a gap between subject who were exposed and unexposed. Note that we must pass the transpose of the matrix for the pheatmap
function, which is not the case for other functions such as gplots::heatmap.2
.
Update: June 25, 2015
Interactive Heatmaps using d3heatmap
It is also possible to create Interactive heatmaps (in the sense that you can see the actual values by hovering your mouse over the plot) using the d3heatmap
pacakge available on github:
This is useful if you are producible markdown reports. The syntax is standard, though does not allow for multiple annotations as in pheatmap
.
For some reason, this map is not showing up on this website, but it should work when compiling Rmarkdown scripts and viewing the resulting HTML document in your browser or within RStudio.
Update: August 7, 2015
Interactive Heatmaps using plotly
After some user setup (see the plotly help page), the following code creates an interactive heatmap:


The Time Tracker was my senior project during my final semester at Westminster College. My goals setting out at the start of my final semester was to create a fantastic desktop experience, a JSON mobile API, and a mobile app to interface with the API.
Speed was key to complete this project. I needed to develop and deploy rapidly considering the short time span for this project. These constraints affected the tools I used to build The Time Tracker.
Ruby on Rails is a MVC framework based off of Ruby. I decided early on that this would be the basis for the desktop experience and mobile api. While I had no Rails experience and minimal Ruby experience going into this project, I hoped its similarity to Python would give me a good head start. One of the guiding principles in the Rails community is "Convention over Configuration". I found this to be both a blessing and a curse. At times I was grateful to have Rails handling more of the tasks I didn't feel like dealing with, while other times I spent many wasted hours trying to find documentation about some small method that it turns out was quite needed.
For the mobile experience I chose the Ionic Hybrid App Framework. Ionic is a package based off of AngularJS, designed exclusively for near native mobile apps written in HTML, CSS, and JavaScript. I found Ionic was perfect for rapidly writing and deploying my app. Since it's foundation is based off of AngularJS, there were plenty of guides and tutorials to help me through writing my application.
In the Spring of 2014 for a Software Engineering class, my classmates Nicole, Charles, Anna, and myself were assigned to build a math game for 2nd and 3rd graders. After quickly coming up with the name Knack. (Knack Nicole Anna Charles Kyle). We started off.
When we started designing Knack we had little experience with web development. Nicole had quite a bit of HTML and CSS experience. We wanted to do a web framework since they are so commonly used in the job market. We decided on Django since Nicole and I had quite a bit of Python experience as well.
Since this was a group project, easy code sharing and collaboration was crucial. We chose to use GitHub for our project. We found that this helped us in more ways than just code sharing. It let us add bugs, set tasks, even basic scheduling and releases.
Throughout our project we consistently met our set deadlines, had very successful 1st, 2nd, and final releases. And demonstrated a solid usable web based math game for children.
For a Computer Graphics class, we were assigned to build ray tracers over the course of a semester. We were allowed to use any infrastructure we liked. The class was split nearly 50/50 on Python and Java. I decided to go with a Python based ray tracer.
We built our ray tracers through the semester. As we learned more complex graphics ideas in class, we added them to our ray tracer. Looking at the output from the images we made, you can really see the progression through the semester.
One of the only downsides to using Python was a performance hit. Since Python is an interpreted language, the class in general found it to be a bit slower than Java. But once I set up the PyPy interpreter, my ray tracer ray about 100x faster. Renders that used to take upwards of 10 minutes now took only about 10 seconds.
In a Artificial Intelligence class we built Maze Solvers to demonstrate different search algorithms. We implemented the UCS, BFS, DFS, and AStar algorithms. Using a text based maze we filled in different methods to implement the algorithms. This really illustrated how much more effective some algorithms are in solving mazes than others.
In the above examples, make sure to note the different costs between the algorithms. Lower costs are better. Follow the periods to see the path the algorithms took.
During one of the first classes I took at Westminster, in a group project with one other classmate, we were assigned to build a client and server for a network protocol the class made. In a class meeting we as a class designed a network protocol for an instant messenger. Starting with a web server that we had built earlier in the semester, we decide to build a Java based server, and a Python based client.
Once we had finished the project, the client could communicate with the server, and send public and private messages to other clients, even if we didn't create them. It was really exciting to get together on the last day of class with my other classmates and try out our clients together. It was a great example of how a network protocol worked.


- The environment is similar to the regular web IDE used for backtesting/live trading
- Tasks are preceded with text to guide you, you may need to use some of the snippets in the
- Lessons have multiple tasks to test your understanding
- You'll need to code with our assistance
- When you run the algorithm, you'll know if you did things correctly or not
- Hints are provided if you need more help
- You can view the solution file to check your answers


We offer car financing services. You will have to get a loan from the bank or at any finance company. After that, stop by and we will use the loan in paying off the car that you want.
We offer car leasing services! Lease a car for 24 months, 36 months, or 48 months. Come stop by and get the best prices on leasing the car you want!
Leave your car in good hands! We offer oil change, battery change, tire rotation, NYS inspection, and more! Stop by with your car and we will get you back on the road in no time!


Have you suffered a challenging experience while trying to gain control over the mobile technology and devices in your organization? Well, you aren't alone. Organizations around the globe are dealing with the same issues.
Tip #60: Merging Your Professional Life & Personal Life, All in One
Tip #67: Hackers Will Try Anything
Tip #24: Tablets aren't Toys
Tip #33 MDM Newsreel
Tip #71: Not all Applications are Created Equal
Tip #3: A Lost Phone is no Reason to Panic
Tip #49: Picture ID Not Required When Using MDM Software
Tip #75: Don't Treat Lucky Caller #7 Like a Security Threat
Tip #28: Human Device Lock
Tip #111: An Unprotected Cell Phone is a Huge Risk. A Brick Isn't
Tip #98: It Always Starts With Just One Request
Tip #131: No Device- Personal or Work- Operates When Wet
Tip #174: Don't Risk the Business Over Four Digits
Tip #11: Don't Pay the Price of Free Apps
Tip #67: Multiple Devices Create Multiple Problems
Tip #84: Sloppiness is a choice. MDM isn't
Tip #114: They Can't Outrun MDM
Tip #72 Tee Up MDM for Secure Access, Anywhere
Tip #336: All QR Codes Aren't Created Equal, or Secure
Tip #116: Without Security, a Smartphone is a Megaphone
Tip #471: Blocking Attachments Isn't the Answer
Tip #782: Blocking App-by-App is Futile
Tip #118: It Doesn't Take a Wizard to Undermine Security
Tip #297: Secure Environments Come from Secure Back Ends


Here's my exercises for graphic design with Photoshop and Illustrator. Some are from tutorials, mostly Andrei Marius and Andrew Rosek.


--- layout: default title: API Requests permalink: /housekeeping-api-requests ---
The total number of GitHub API requests.
High numbers usually indicate unfavorably configured CI processes.
This table lists the resources requested via the API that accounted for the majority of API requests yesterday.


| Package | Description |
|---|---|
| net.shibboleth.utilities.java.support.component |
Set of interfaces used to describe basic features of "components" or "modules" within a larger system.
|
| net.shibboleth.utilities.java.support.httpclient |
Classes for working with Apache HttpClient.
|
| net.shibboleth.utilities.java.support.net |
Classes for working with HTTP URLs and the protocol.
|
| net.shibboleth.utilities.java.support.security |
Helpers for common security related tasks.
|
| net.shibboleth.utilities.java.support.service |
Service support for Shibbleth projects.
A service is something reloads instances of serviceable components. |
| net.shibboleth.utilities.java.support.xml |
A set of helper functions for performing actions on DOM nodes.
|
| Class and Description |
|---|
| AbstractIdentifiedInitializableComponent
Simple implementation of
InitializableComponent and IdentifiedComponent . |
| AbstractInitializableComponent
Base class for things that implement
DestructableComponent and InitializableComponent . |
| Component
A marker interface that represents something used as a discrete part of a larger system.
|
| ComponentInitializationException
Exception thrown if there is a problem initializing a component.
|
| DestructableComponent
A component which can be destroyed and its resources reclaimed.
|
| IdentifiableComponent
A
Component whose identifier can be set. |
| IdentifiedComponent
A
Component which has an identifier. |
| InitializableComponent
A
Component which needs to be initialized prior to any "real" use. |
| Class and Description |
|---|
| Component
A marker interface that represents something used as a discrete part of a larger system.
|
| ComponentInitializationException
Exception thrown if there is a problem initializing a component.
|
| DestructableComponent
A component which can be destroyed and its resources reclaimed.
|
| InitializableComponent
A
Component which needs to be initialized prior to any "real" use. |
| Class and Description |
|---|
| AbstractInitializableComponent
Base class for things that implement
DestructableComponent and InitializableComponent . |
| Component
A marker interface that represents something used as a discrete part of a larger system.
|
| ComponentInitializationException
Exception thrown if there is a problem initializing a component.
|
| DestructableComponent
A component which can be destroyed and its resources reclaimed.
|
| InitializableComponent
A
Component which needs to be initialized prior to any "real" use. |
| Class and Description |
|---|
| AbstractIdentifiableInitializableComponent
An
AbstractIdentifiedInitializableComponent with a public setter. |
| AbstractIdentifiedInitializableComponent
Simple implementation of
InitializableComponent and IdentifiedComponent . |
| AbstractInitializableComponent
Base class for things that implement
DestructableComponent and InitializableComponent . |
| Component
A marker interface that represents something used as a discrete part of a larger system.
|
| ComponentInitializationException
Exception thrown if there is a problem initializing a component.
|
| DestructableComponent
A component which can be destroyed and its resources reclaimed.
|
| IdentifiableComponent
A
Component whose identifier can be set. |
| IdentifiedComponent
A
Component which has an identifier. |
| InitializableComponent
A
Component which needs to be initialized prior to any "real" use. |
| UnmodifiableComponent
A marker interface for components that may be put in to an unmodifiable state and, if a modification is attempted
afterwards, throws
UnmodifiableComponentException . |
| Class and Description |
|---|
| AbstractIdentifiableInitializableComponent
An
AbstractIdentifiedInitializableComponent with a public setter. |
| AbstractIdentifiedInitializableComponent
Simple implementation of
InitializableComponent and IdentifiedComponent . |
| AbstractInitializableComponent
Base class for things that implement
DestructableComponent and InitializableComponent . |
| Component
A marker interface that represents something used as a discrete part of a larger system.
|
| ComponentInitializationException
Exception thrown if there is a problem initializing a component.
|
| DestructableComponent
A component which can be destroyed and its resources reclaimed.
|
| IdentifiableComponent
A
Component whose identifier can be set. |
| IdentifiedComponent
A
Component which has an identifier. |
| InitializableComponent
A
Component which needs to be initialized prior to any "real" use. |
| UnmodifiableComponent
A marker interface for components that may be put in to an unmodifiable state and, if a modification is attempted
afterwards, throws
UnmodifiableComponentException . |
| Class and Description |
|---|
| AbstractInitializableComponent
Base class for things that implement
DestructableComponent and InitializableComponent . |
| Component
A marker interface that represents something used as a discrete part of a larger system.
|
| ComponentInitializationException
Exception thrown if there is a problem initializing a component.
|
| DestructableComponent
A component which can be destroyed and its resources reclaimed.
|
| InitializableComponent
A
Component which needs to be initialized prior to any "real" use. |
Copyright © 1999–2016 Shibboleth Consortium. All rights reserved.


SafeOrbit.Memory Namespace
Classes
| Class | Description | |
|---|---|---|
| InitialSafeObjectSettings |
Initial settings for SafeObject<(Of <(<'TObject>)>)> instances
|
|
| SafeBytes | ||
| SafeContainer |
SafeContainer is a lightweight object container with memory protection.
|
|
| SafeContainerWrapper<(Of <(<'TComponent>)>)> |
IFactory<(Of <(<'TComponent>)>)> implementation, using ISafeContainer.
|
|
| SafeMemoryStream |
Creates a stream with no backing store (ephemeral memory).
|
|
| SafeObject<(Of <(<'TObject>)>)> |
SafeObject<(Of <(<'TObject>)>)> uses and tracks any outside modifications of the TObject. Provides thread safe access to its inner object. Important: Use only ApplyChanges(Action<(Of <<'(TObject>)>>)) to change the state of your object. It'll authorize your access and apply them securely. Its security is based on IInjectionDetector and alerts if unknown changes to the object occurs based on current SafeObjectProtectionMode. |
|
| SafeObjectFactory | ||
| SafeString | ||
| SafeStringToStringMarshaler |
Lets you use the SecureString inside SafeString until it's disposed Creates an allocated string in the memory after setting its SafeString property. The place and the string is removed from the memory after disposing it. |
Interfaces
| Interface | Description | |
|---|---|---|
| IInitialSafeObjectSettings |
Abstraction of a class that holds some values for initial settings of ISafeObject<(Of <(<'TObject>)>)>
|
|
| IInjectionDetector |
IInjectionDetector abstracts a service that keeps track of C# objects and classes. It alert .
|
|
| ISafeBytes | ||
| ISafeContainer |
Abstraction for a factory class that's protected in memory. It abstracts strategies for different protection modes |
|
| ISafeObject<(Of <(<'TObject>)>)> | ||
| ISafeObjectFactory | ||
| ISafeString | ||
| ISafeStringToStringMarshaler |
Abstract a marshaler that can convert a ISafeString into a String until it is
disposed
|
Enumerations
| Enumeration | Description | |
|---|---|---|
| InjectionType | ||
| InstanceProtectionMode |
Different protection modes for a ISafeObject<(Of <(<'TObject>)>)>
|
|
| LifeTime |
Specifies the lifetime of a service in an [IInstanceProvider].
|
|
| SafeContainerProtectionMode |
Protection levels for ISafeContainer instances.
|
|
| SafeObjectProtectionMode |
Different protection modes for a ISafeObject<(Of <(<'TObject>)>)>
|


|
Awesome Portable Rendering Interface Library
This library provides a universal rendering API and does not require to write code that is used in only one API (e.g. OpenGL, DirectX, SDL, ...)
|
Controller buttons. More...
#include <Keys.h>
Public Member Functions | |
| Button (chstr name) | |
| Button (chstr name, unsigned int value) | |
| Button | next () const |
| Button | previous () const |
| bool | operator< (const Button &other) const |
| bool | operator> (const Button &other) const |
| bool | operator<= (const Button &other) const |
| bool | operator>= (const Button &other) const |
| bool | operator== (const Button &other) const |
| bool | operator!= (const Button &other) const |
Static Public Member Functions | |
| static int | getCount () |
| static hltypes::Array< Button > | getValues () |
| static hstr | getEnumName () |
| static hltypes::Map< unsigned int, hstr > | getAsMap () |
| static Button | fromInt (int value) |
| static Button | fromUint (unsigned int value) |
| static Button | fromName (chstr name) |
| static bool | hasValue (chstr name) |
| static bool | hasValueFor (int value) |
| static bool | hasValueFor (unsigned int value) |
Static Public Attributes | |
| static const Button | None |
| static const Button | Start |
| static const Button | Select |
| static const Button | Mode |
| static const Button | A |
| static const Button | B |
| static const Button | C |
| static const Button | X |
| static const Button | Y |
| static const Button | Z |
| static const Button | L1 |
| static const Button | R1 |
| static const Button | L2 |
| static const Button | R2 |
| static const Button | LS |
| static const Button | RS |
| static const Button | DPadDown |
| static const Button | DPadLeft |
| static const Button | DPadRight |
| static const Button | DPadUp |
| static const Button | AxisLX |
| static const Button | AxisLY |
| static const Button | AxisRX |
| static const Button | AxisRY |
| static const Button | TriggerL |
| static const Button | TriggerR |
Protected Member Functions | |
| Button (unsigned int value) | |
| hltypes::Map< unsigned int, hstr > & | _getInstances () const |
Controller buttons.


In this assignment, you’ll create and export a classes that facilitate subnetting or supernetting of IPv4 networks when provided an IPv4 address and target prefix length, as well as an optional current prefix length, returning the relevant resulting network information.
| Assigned | Tue, Nov 21, 2023 |
| Office hours | By appointment |
| Assignment Due | Tue, Nov 28, 2023 |
The IP protocol is the basis for all internet communication, and it operates at the network layer (layer 3) of the 5-layer Internet model.
IPv4 and IPv6 have significant differences, and almost can be thought
of as distinct protocols. One of the major differences is in the
addressing scheme. IPv4 addresses are 32-bit values often represented
in dotted-decimal format, segmented into 4 8-bit portions, each
portion displayed as a decimal number between 0 and 255, with portions
delimited by a decimal point (.
). IPv6 addresses, on the other hand, are
128-bit values, represented in 8 16-bit portions in hexadecimal form
delimited by colons (:
). IPv6 addresses are often abbreviated by leaving
out leading zeros in each portion, replacing all-zero portions with just
a single 0 digit, and by replacing long strings of consecutive all-zero
portions with double-colons (::
).
IP addresses represent both the ID of the network to which they belong as well as the ID of the host machine on that network. In order to do that, a specific number of contiguous bits on the leftmost side of the address (in binary form) are allocated as the network ID, and the remainder are allocated to the host ID. This location at which this change from bits being allocated to network ID to bits being to the host ID is called the network/host boundary. Traditionally (in IPv4), these allocations happened at octet boundaries, resulting in network ID lengths of 8, 16, or 24 bits, depending on the type of network and its addressing needs.
For this assignment, we’ll be focused on IPv4 addresses only, but the process of subnetting and supernetting is quite similar for IPv6.
However, the way IPv4 addresses are assigned has changed over time. Early on, there were a collection of rules for assigning IPv4 network addresses and and setting the location of the network/host boundary for them that we now refer to as “classful addressing”. These rules resulted in excessive resources needed to maintain and route IP traffic, particularly with respect to size of routing tables. As the Internet grew and more networks were added, there were concerns about exhausting the IPv4 address space. These rules involved assigning default “subnet masks” to 5 ranges of addresses classified by their initial 1-3 bits:
0
(first octet in decimal between 0
and 127) for use on networks with between 65,535 and 16,777,214 hosts.
Default subnet mask: <IP_ADDRESS>
(first octet in decimal between
128 and 191) for use on networks with between 255 and 65,534 hosts.
Default subnet mask: <IP_ADDRESS>0
(first octet in decimal between
192 and 223) for use on networks with 254 or less hosts. Default subnet
mask: <IP_ADDRESS>10
(first octet in decimal between
224 and 239) for use for IPv4 multicast traffic. Default subnet mask:
<IP_ADDRESS>11
(first octet in decimal between
240 and 255) for experimental purposes. Default subnet mask: <IP_ADDRESS>In the late 1980s and early 1990s, the explosion of new Internet hosts (a consequence of what is commonly referred to as the .com boom) caused pressure on routing tables, and the rate of allocation of Class A and B network addresses became unsustainable. Because Class C networks were not able to be combined under the classful system, the end result of this would have been an exhaustion of available IPv4 network addresses before the end of 1995. To prevent this, the rules for assigning IPv4 addresses to networks changed in a few important ways in order to allow setting the network/host address boundary within an IPv4 address optimally for the needs of the network.
The first change was the ability to use variable-length subnet masking (VLSM).
Rather than have fixed subnet masks for each class, the removal of classes as an
address construction principle allowed for any bit-length for the network ID
portion of the IPv4 address. Hence, rather than only allowing subnet masks
of <IP_ADDRESS> (= 1111 1111 0000 0000 0000 0000 0000 0000
), <IP_ADDRESS>,
(= 1111 1111 1111 1111 0000 0000 0000 0000
) and <IP_ADDRESS>
(= 1111 1111 1111 1111 1111 1111 0000 0000
), the prefix of ones in the subnet
mask could end anywere within an octed. Thus subnet masks could end not only
in 0 and 255, but also at 128, 192, 168, 224, 240, 248, 252, and 254.
Accompanying this change was a change, called classless inter-domain routing (CIDR),
to the way network addresses (and their associated subnet masks) are written.
This method of writing a network address indicates the subnet mask as the length
of the all-1s prefix of the subnet mask after the network address, separated from
the IPv4 address of the network with a slash (/
). For example, the network address
associated with the IP address <IP_ADDRESS>
with a subnet mask of <IP_ADDRESS>
would be written in CIDR form as <IP_ADDRESS>/26
, with a host ID of <IP_ADDRESS>
.
As mentioned above, the goal of VLSM was to allow for finer-grained control over the size of an address block assigned to a network by moving the network/host boundary to a more optimal location within the IPv4 addresses of the network.
To complete this assignment, you need to write and export two classes:
IPv4Address
classAn IPv4Address
class that can be instantiated with:
new IPv4Address(
/* IPv4 address in binary/unsigned integer format */
0b00001100_00101110_11010101_00111001,
/* IPv4 subnet mask in binary/unsigned integer format */
0b11111111_11111111_11000000_00000000
)
Instances of the IPv4Address
class should have properties:
networkID
- binary IP network IDhostID
- binary IP host IDprefixLength
- integer network prefix lengthsubnetMask
- binary IP subnet masknetwork
- an IPNetwork
instance specifying information about the
IPv4 network to which this address belongsThe IPv4Address
class should have the following static methods:
display(<Buffer> address) -> <string>
- to convert binary IPv4 addresses
into human-readable onescreate(<number|string> ip4Address, <number|string> subnetMask) -> <IPv4Address>
-
to create IPv4Address
objects from either binary or string representations of
the address and possibly the subnet as follows:
IPv4Address.create(
/* IPv4 address in binary/unsigned integer format */
0b00001100_00101110_11010101_00111001,
/* IPv4 subnet mask in binary/unsigned integer format */
0b11111111_11111111_11000000_00000000
)
IPv4Address.create(
/* IPv4 address in CIDR string format */
'<IP_ADDRESS>/18'
)
IPv4Address.create(
/* IPv4 address on the network in string human-readable format */
'<IP_ADDRESS>',
/* IPv4 subnet mask on the network in string human-readable format */
'<IP_ADDRESS>'
)
IPv4Network
classThe IPv4Network
class that can be instantiated with:
new IPv4Network(
/* IPv4 address on the network in binary/unsigned integer format */
0b00001100_00101110_11010101_00111001,
/* IPv4 subnet mask in binary/unsigned integer format */
0b11111111_11111111_11000000_00000000
)
IPv4Network
instances should should have properties:
networkID
- binary IP network addressprefixLength
- the network prefix lengthnetworkCIDRAddress
- the binary IP network address and integer prefix
length combined in a human-readable CIDR format stringsubnetMask
- binary subnet mask for the network’s prefix lengthbroadcastAddress
- binary IP address used for broadcast on the networkhostAddressRange
- 2-element array containing the minimum and maximum
binary host IP addresses in the networkMethods on IPv4Network
:
subnet(<integer> newPrefixLength) -> <IPv4Network[]>
-
a method that subnets the network and returns an Array
of IPv4Network
instances for each of the subnetssupernet(<IPv4Network[]> networks) -> <IPv4Network[]>
-
a method that takes a collection of networks and combines them into a
minimally covering collection of as few networks as possible, returning
an Array
of IPv4Networks
. (Note: you cannot supernet an
incomplete covering of the address space, so be sure that every
address in the range of addresses covered by your supernet result
is also covered by the one of the networks passed in.)create(<number|string> ip4Address, <number|string> subnetMask) -> <IPv4Network>
-
a method that takes either an IPv4 address as a CIDR format string, or an IPv4
address and subnet mask, and creates and returns an IPv4Network
instance:
IPv4Network.create(
/* IPv4 address on the network in binary/unsigned integer format */
0b00001100_00101110_10001000_00101111,
/* IPv4 subnet mask in binary/unsigned integer format */
0b11111111_11111111_11000000_00000000
)
IPv4Network.create(
/* IPv4 network address in CIDR string format */
'12.46.128/18'
)
IPv4Network.create(
/* IPv4 address on the network in CIDR string format */
'<IP_ADDRESS>/18'
)
IPv4Network.create(
/* IPv4 network address in string human-readable format */
'<IP_ADDRESS>',
/* IPv4 subnet mask in string human-readable format */
'<IP_ADDRESS>'
)
While you must make your implementation pass automated tests that
will only use the exports from index.js
, you will need to create
the classes each in their own file as a library, and re-export them
from the main index.js
file.
Each of these classes should be well-tested (repeatably via automation),
so that you can be confident of the accuracy and error-free quality of
your parsing code. Each of the classes and their methods should also
include relevant documentation in JSdoc format
about why they exist, including expected inputs and outputs with data
types.
In this repo, you will find an index.js
file, where the classes you are
expected to create are imported and re-exported. You may choose to augment this
with any other objects or funcitons your library needs to provide as part of
its public interface, however you should not need to. You will also find a
lib
folder, in which there are two empty JavaScript files – one for each
class you will create and export.
In this assignment (as in prior assignments in this course), you’ll be
working with binary data in JavaScript. The interface for this work
will almost always be the Buffer
class and its subclasses. Get to know
the Buffer
class as soon as possible.
In particular, you’ll need to be very familiar with the methods to read
various length unsigned integers, including the little endian (LE) and
big endian (BE) variants and how to choose which variant you need, and the
subarray
method, as well as the typed subclasses of Buffer
.
As you’ll recall from assignments A4 and A5, to work with individual bits,
you’ll need to take a byte and bit-shift or bit-mask it to get the specific
bit you’re looking for. For example, you to get the third bit from the left
in 0x6d = 109 = 0b01101101
, you would could do this by:
0b00100000
.AND
operation
between the byte you’re extracting from and the bit mask you created.
In JavaScript, this example looks like: 0x6d & 0b00100000
.(0x6d & 0b00100000) >>> 5
This has relevance to creating and working with subnet masks, which are just bit masks that operate across all 32 bits in the IPv4 address at once.
To create a subnet mask from the prefix length, you can begin with a
32-bit binary value comprised of all 1
s and do the following:
1
s>>>
) away the bits that should be 0
s<<
) back the same amount to return to the right total length>>>
) by 0
to ensure an unsigned integer valueFor example, if the prefix length is 8
, this looks like:
const prefixLength = 8;
const SUBNET_MASK_BASE = 0b11111111111111111111111111111111; // =><PHONE_NUMBER>
const numZeroBits = 32 - prefixLength;
const subnetMask = (SUBNET_MASK_BASE >>> numZeroBits << numZeroBits >>> 0);
subnetMask // =><PHONE_NUMBER>
subnetMask.toString(2) // => '11111111000000000000000000000000'
Once you have a subnet mask, finding the network ID is just a bitwise
AND
operation:
const ip4addr = Buffer.from([10, 105, 241, 58]).readUInt32BE();
// ip4addr === 0b1010011010011111000100111010
const networkID = subnetMask & ip4addr;
// networkID === 0b1010000000000000000000000000
And finding the host ID is a bitwise AND
operation with the bitwise
negation (NOT
) of the subnet mask:
const ip4addr = Buffer.from([10, 105, 241, 58]).readUInt32BE();
// ip4addr === 0b1010011010011111000100111010
const hostID = ~subnetMask & ip4addr;
// hostID === 0b0000000011010011111000100111010
As with Assignments A1 and A4, in order to get started with the assignment, you’ll want to do the following things:
Run the following at the command line from within the project directory (use
cd <path>
, replacing <path>
with the folder path to your project directory,
to get there):
nvm install 14.15
nvm use 14.15
npm install
npm test
During development, you may wish to run the tests in watch mode, so that each time you save a file, the tests that file affects will run. To do this, you can use:
npm test -- --watch
This assignment will also automatically check your code style for readability. To run those tests at your own command line, you can use:
npm run lint
You must submit your changes as commits to the main
branch on the repository.
Github Classroom will create a pull request on the repository for you, titled
Feedback. As you push your commits on the main branch up to Github, they
will be added to the activity on this pull request.
In addition to the synchronous mechanism of requesting help via office hours appointments, this pull request will be your mechanism for asking questions and requesting help asynchronously during the course of this assignment. I will also use this pull request to provide feedback on your work. I will provide feedback on the completed assignment within a week of the due date of the assignment. If you push your code earlier than the due date, I will try to provide feedback as needed earlier.
I suggest that you push your work to Github as you make commits, and that you make
commits frequently as you work on the assignment. This way, if you have questions,
I will be able to review your work-in-progress and give more relevant answers and
feedback. If you have a question specific to a particular area of the code, note that
you can add comments inline on the pull request by clicking on the Files changed tab
of the pull request, then clicking the little blue +
icon that appears when you hover
over a specific line of code.
I will do my best to respond to questions posed during the course of the assignment with
in a day of the ask. If you want to ask a question or request early feedback, please tag
me in a comment on the pull request: @nihonjinrxs
.
Good luck, and I look forward to seeing what you create!


Reports unnecessary def modifiers when used with explicit type declaration.
For example:
def boolean foo() {} // modifier is unnecessary
def Object bar // modifier is unnecessary
def (int a, String b) = [] // modifier is required and therefore not highlighted


My name is Pawel and I was born in a small town in Poland - Tarnow. That is where I spent most of my life and 5 years ago I have moved to England.
I graduated from high school in Tarnow with with a high proficiency in electronics. My background experience mostly includes working with CNC machines although I'm in the process of becoming a web developer, which became my long-term goal.
I decided to start studying web development because it became one of my hobbies and I wanted to combine a hobby with a profession. In my free time I also like playing sports, reading and listening about new technologies and engineering.
Throughout the course I learnt a lot of new technologies. HTML, CSS and JavaScript are just the foundation, besides them I also know jQuery, node.js, express.js, mySQL and more.