Name:
State:
Durable:
Lifespan:
Inbound:
msg/s
Outbound:
msg/s
Store Type:
Store Path:
Config Path:
Add Exchange
Delete Exchange
Add Queue
Delete Queue
Queue Depth:
msgs
Queue Depth:
Message Age:
Message Size:
Alert frequency:


A Work Package represents a series of actions identified and designed to achieve specific results within specified time and resource constraints.
The central behavioural element is a Work Package. A Work Package is a behaviour element that has a clearly defined start and end date, and realizes a well-defined set of Goals or Deliverables. The Work Package element can be used to model sub-projects or tasks within a project, complete projects, programs, or project portfolios.
Implementation and Migration
"Program to sustain implementation", "Project to secure funding", "Project for CRM system integration"


| # | Data Type | Progress | |
|---|---|---|---|
| 1. | Customers |
|
{{ percent }}% |
| 2. | Customer Types |
|
{{ percent }}% |
| 3. | Industry Types |
|
{{ percent }}% |
| 4. | Lead Source Types |
|
{{ percent }}% |
| 5. | Orders |
|
{{ percent }}% |
| 6. | Order Statuses |
|
{{ percent }}% |
| 7. | Rating Types |
|
{{ percent }}% |
| 8. | Title Types |
|
{{ percent }}% |


nanoJS is around 100 lines of code (1.2 Kb compressed) JavaScript library for basic DOM manipulation. It has jQuery like syntax and supports chaining.
Because is so small and simple you can add or remove methods directly in the library, meaning is very customizable. All methods are unrelated so removing one will not affect the library in any way (except each method).
Use this library as starting point and personalise it so it can meet your needs. We often use huge JavaScript libraries and framework for basic tasks.
Here are some code examples:
$(".someClass").css("background-color:green;").html("Hello World");
$('#c').animate('2.3', '1.2','0','1','1','0','0', '0','0','1').css('background-color:red').text('Hello');
$("#a").on("click", function(){ $("#someDiv").css("background-color:green;color:#fff;"); })
It uses familiar jQuery like syntax.
It works in IE9 and later.


Cheezoid drawing board
px to cm:
Draw & Move
Just Move
This page assumes cheezoid's starting position is facing up 600x600 px


Post #6: Object Oriented Programming: Methods
Instance vs. Class Methods
June 26, 2015
Upon being assigned a few OOP topics to choose from, I selected to research and write about instance vs. class methods. My understanding of classes as a concept in general is something I want to better solidify. I learn best through doing research, seeing examples, and then applying the concepts in creative practice. In a recent session with a guide, she demonstrated creating a class method using self
within the class. This did not click for me initially, so I spent some time researching self and exploring how this relates to instance vs. class methods.
Class methods are those that can be called on the original created class. Instance methods; however, can only be called on new instances of that created class. I found basic examples like the one below to be helpful in the introduction of this idea.
class Name def initialize(name) @name = name end def introduce puts "My name is<EMAIL_ADDRESS>end end
Within the class Name
, an instance method introduce
was created. We can call the method introduce
on any instance of the class Name
. I cannot; however, call the method introduce
on the class itself.
dan = Name.new("Dan") dan.introduce # My name is Dan.
However if we try to call the following, we will get an error.
Name.introduce #undefined method 'introduce' for Name:Class
We can define a class method as well.
class Name def self.class_method puts "I am calling a class method now." end def initialize(name) @name = name end def introduce puts "My name is<EMAIL_ADDRESS>end end
We can then call the class method.
Name.class_method # I am calling a class method now. dan.class_method # undefined method 'class_method' for (instance of Name class)
Below is a class I created to experiment with my understanding of instance verses class variables that imitated my recent assignment.
ROSTER = {:Audrey=> {position: "setter", jersey: 1}, :Juana => {position: "libero", jersey: 21}, :Rut => {position: "defense", jersey: 3}} class VolleyballPlayer def self.introduce_team puts "This is a class method" ROSTER.each do |player, info| puts "Number #{ROSTER[player][:jersey]} is #{player} playing #{ROSTER[player][:position]}" end end def initialize(player, position, jersey) @player = player @position = position @jersey = jersey end def introduce_player puts "This is an instance of the class VolleyballPlayer" puts "Number<EMAIL_ADDRESS>is #{@player} playing<EMAIL_ADDRESS>end end audrey = VolleyballPlayer.new("Audrey", ROSTER[:Audrey][:position], ROSTER[:Audrey][:jersey]) audrey.introduce_player rut = VolleyballPlayer.new("Rut", ROSTER[:Rut][:position], ROSTER[:Rut][:jersey]) rut.introduce_player juana = VolleyballPlayer.new("Juana", ROSTER[:Juana][:position], ROSTER[:Juana][:jersey]) juana.introduce_player VolleyballPlayer.introduce_team
This would result in the following pritning to the console:
This is an instance of the class VolleyballPlayer Number 1 is Audrey playing setter. This is an instance of the class VolleyballPlayer Number 3 is Rut playing defense. This is an instance of the class VolleyballPlayer Number 21 is Juana playing libero. This is a class method Number 1 is Audrey playing setter Number 21 is Juana playing libero Number 3 is Rut playing defense
Instance methods are the best option for creating single instances of a class. Like one version of a player introduction, in my case. In the case of wanting to create a series of instances or a data table, for example, you might consider creating a class method that generates a group of instances.