Kyoko Fischer
Artist Statement
The process of creating art, along with its relationship to shapes and
lines, gives me a feeling of nostalgia and calmness. My art allows me to
not only time travel to a past that cannot be otherwise reached – it
produces a continuum between the past and the present that I can access
and find new, surprising information for me to digest and think more
about life for being human. The sky I looked up at eight years old is
the same sky I see today, and I express that through my artwork; the
green leaf falling by me at six years old produces the same feeling in
me when a red leaf falls to the ground today, and I represent that
through my art.
My artwork explores the intersection of the past and the present, as
well as the beautiful tensions emerge as a result. Over the last several
years, I have devoted myself to studying Japanese history and culture,
particularly with an eye on mingei – or art objects made by ordinary
people during the Edo period. I continually ask myself what it means to
incorporate and reimagine mingei in today’s modern art context; this
question allows me to creatively bridge a gap of over four hundred years
and shed new light on a tradition not only time-honored, but time-bound
as well.
Solo Thesis Exhibition Images
Kyoko Fischer
Sashiko: On Paper, 2019
Lithography, intaglio, paper thread
48 x 90 in
Kyoko Fischer
Sashiko: On Paper, 2019
Lithography, intaglio, paper thread
48 x 90 in
Kyoko Fischer
Sashiko: On Paper, 2019
Lithography, intaglio, paper thread
48 x 90 in
Kyoko Fischer
Sashiko: On Paper, 2019
Lithography, intaglio, paper thread
48 x 90 in
Kyoko Fishcer
Sashiko: On Paper, 2019
Lithography, intaglio, paper thread
48 x 90 in


Nucleator CLI Reference
nucleator-beanstalk(1) Manual Page
NAME
nucleator-beanstalk - Provision, Configure and Invoke Operations on Elastic Beanstalk Applications and Environments in Nucleator Cages
SYNOPSIS
nucleator beanstalk provision <args> [options] nucleator beanstalk configure <args> [options] nucleator beanstalk deploy <args> [options] nucleator beanstalk delete <args> [options]
DESCRIPTION
The beanstalk command and its subcommands are used to create and maintain Elastic Beanstalk Applications and Environments within Nucleator Cages.
Running nucleator beanstalk provision and nucleator beanstalk configure multiple times is safe, because provisioning and configuration operations are idempotent. If no changes have been made to the Stackset definition in ~/.nucleator/contrib/beanstalk, these commands will result in no change. If updates were made to to the Stackset definition (via nucleator update, for example) that are consistent with CloudFormation’s "update in place" capabilities, the Stackset will be updated in place so that AWS Resources are brought into alignment with the new Stackset definition. This can be useful, for example, when modifying security groups to support application communication on various ports that the app may require.
The beanstalk command provides the ability to easily manage provisioning parameters supporting setup and common scaling operations via the Nucleator CLI.
SUBCOMMANDS
BEANSTALK PROVISION
- nucleator beanstalk provision
-
--customer <customer_name> --cage <cage_name> --app_name <beanstalk_application_name> --type <application_type> [--tier <tier_type>] [--beanstalk-instance-type <ec2_instance_type>] [--database-instance-type <rds_instance_type>] [--database-name <database_name>] [--database-user <database_user>] [--database-password <database_password>] [--minscale <min_value>] [--maxscale <max_value>] [--service-role <iam_role_name>] [--queue-url <url>] [--inactivity-timeout <timeout_value>] [--visibility-timeout <timeout_value>] [--preview] [-h | --help]
nucleator beanstalk provision creates an AWS Elastic Beanstalk application and environment in the specified Cage for the specified Customer. It can also provision a backing RDS database for persistence of application state.
The subcommand provisions an autoscaling environment that spans the two availability zones defined in the Cage configuration for the specified Cage. The min, max and desired autoscaling targets can be specified using subcommand options.
BEANSTALK CONFIGURE
- nucleator beanstalk configure
-
--customer <customer_name> --cage <cage_name> --app-name <beanstalk_application_name> [-h | --help]
nucleator beanstalk configure performs post-provisioning configuration of all EC2 resources associated with the beanstalk.
By default all hosts associated with any instance of the beanstalk Stackset within the specified Cage will be configured. The app-name option can be used to optionally constrain the set of configured instances to hosts associated with a specified beanstalk Stackset instance.
BEANSTALK DEPLOY
- nucleator beanstalk deploy
-
--customer <customer_name> --cage <cage_name> --app-name <app_name> --app-version <beanstalk_application_version> --app-url <application_url>
nucleator beanstalk deploy deploys the application deployment artifact at <application_url> (typically drawn from an artifactory) to the beanstalk Stackset instance specified by <app_name>. During deployment, a the specified <beanstalk_application_version> is created within the beanstalk, and deployed to the specified <beanstalk_environment_name> beanstalk environment.
BEANSTALK DELETE
- nucleator beanstalk delete
-
--customer <customer_name> --cage <cage_name> --app-name <beanstalk_application_name>
nucleator beanstalk delete attempts to delete the beanstalk Stackset instance specified by <beanstalk_application_name> from the specified Nucleator Cage.
OPTIONS
- --customer <customer_name>
-
The name of the Customer for whom the specified Cage was provisioned.
- --cage <cage_name>
-
The name of the Cage in which to provision and maintain the beanstalk.
- --app-name <beanstalk_application_name>
-
The name of the elastic beanstalk application to provision, configure, deploy or delete. Note that nucleator will extend this base application name appending "-<cage>-<customer>" to support AWS naming best practices and ensure uniqueness within the target AWS account. So for example if "myapp" is passed as app_name, the provisioned beanstalk will be named "myapp-<cage>-<customer>".
- --type <application_type>
-
The type of application environment to provision. Currently supported application types are "java8", "java7", "nodejs", "python3", "python27", "ruby22_pass", "ruby22_puma", "tomcat8", "tomcat7", "tomcat7java6", "go", "docker17", "docker16". These correspond to the AWS Beanstalk instance types, so you may consult the AWS documentation for details.
- --tier <tier_type>
-
The "tier" of the instance, meaning, either "worker" or "webserver". A web server instance is placed behind a load balancer and gets an internal DNS entry. A worker instance gets an SQS queue associated with it. A daemon is created and runs on the instance which reads that queue and posts messages to the worker application when the queue is read.
- --beanstalk-instance-type <ec2_instance_type>
-
The type of ec2 instance to use within the elastic beanstalk. Must be drawn from the list of currently supported ec2 instance types in aws_service_config.yml. Defaults to "t2.micro". See also [FILES].
- --database-instance-type <rds_instance_type>
-
The type of AWS Relational Database Service (RDS) instance to use within the elastic beanstalk. Must be drawn from the list of currently supported RDS instance types in aws_service_config.yml. Use "None" to signify that no RDS instance should be provisioned. Defaults to "None". See also [FILES].
- --database-name <database_name>
-
The name of the database to provision within the RDS instance provisioned to provide data persistence for the Elastic Beanstalk. Defaults to "nucleator". See also [FILES].
- --database-user <database_user>
-
The database user created in the RDS instance provisioned to provide data persistence for the Elastic Beanstalk. Defaults to "nucleatorAdmin". See also [FILES].
- --database-password <database_password>
-
The password for the database user created in the RDS instance provisioned to provide data persistence for the Elastic Beanstalk. Defaults to "DefaultPassword". See also [FILES].
- --limit-stackset-instance <beanstalk_application_name>
-
Limits stackset configuration to hosts associated with beanstalk Stackset instance <beanstalk_application_name>.
- --minscale <min_value>
-
The minimum number of elastic beanstalk instances in the autoscaling group associated with the elastic beanstalk. Defaults to 1.
- --maxscale <max_value>
-
The maximum number of elastic beanstalk instances in the autoscaling group associated with the elastic beanstalk. Defaults to 4.
- --service-role <iam_role_name>
-
The IAM role to be associated with the instance profile that is associated with beanstalk EC2 resources. Defaults to NucleatorBeanstalkServiceRunner. Applications may wish to use an alternate IAM role if extended permissions to other AWS resources are required by the application.
- --preview
-
When provisioning a beanstalk, rather than provision the beanstalk, print preview information about what will be provisioned if run without the --preview opion. Preview text is intended to be descriptive and may also include links to graphical architecture diagrams.
- -h
- --help
-
Show help for this command.
FILES
- NUCLEATOR_INSTALL_DIR/nucleator-core/lib/nucleator/core/foundation/ansible/roles/config/vars/aws_service_config.yml
-
AWS Services config file including dicts for currently supported EC2 and RDS instance types.
- ~/.nucleator/contrib/beanstalk/ansible/roles/beanstalk_provision/defaults/main.yml
-
Default values for optional arguments to the beanstalk command.
NUCLEATOR
Part of the nucleator(1) suite


I'm sitting at home when I get a call from a good fellow asking me if I may be able to rid him of some redrock he has. This intrigues me leading me to hasten over to a place of meeting.
I was skeptical at first of this substance being sold to me as redrock. I hear that redrock is dragons blood incense sold at an inflated price so I bring this up to the good fellow in possession of this beautiful substance, with a grin he replys with a: 'Well, yes my good friend, it IS dragons blood incense but with a hint of magic to it.' Now this leads me to a fit of confusion as I stand asking myself, 'why would he admit that to me? and why is he grinning?' As I was thinking this, he says to me: 'It's mere dragons blood incense used as a base for a synthetic opioid.'
Now this is really interesting to me and we head over to his pad. This good man proceeds to smoke a bit with me. I find this kind of funny; we were chasing the dragon.
I was a little tired from work but was still in a clear mindset. Completely sober beforehand.
I'm sitting in a comfortable velvetine couch in a large suburban house with no worries and a somewhat overdone art film produced by a local college student playing on the large screen television. He places a good bit, I estimate a half gram or so onto a large peice of foil which has been folded as to have 3 layers. An indirect flame is applied under the substance which melts to a surprisingly blood-like color, texture, and consistancy. As the redrock boiled off the vapors were inhaled through a hollow glass tube. It tasted very sweet with a hint of cinnimon and spice in my opinion and gave off a very pleasant odor which soon overcame the room.
After a few large breaths of this substance a very interesting sence and warmth began surrounding me from my thorax and extending to my limbs. It was a very distinct feeling unlike the usual opioid buzz. Not at all like heroin, dissimiler to Vietnamese opium, vaguely similar to Demerols, but overall more reminiscent of Klonopins or a good pirate shot of rum more than anything else. After completing the remainder of the redrock I felt floaty, distant, uninhibited, drunk, and definately unable to drive. This level of depressent activity came as a surprise to me. I was expecting nothing and a mild opioid buzz at the most. Instead though I find myself in a definate depressant nod. A feeling of nothingness surrounds me like a warm blanket and a sence of vauge darkness is present in the back of my head. Similar to the monster in the closet feeling as a kid but without the fright associated with it. Overall this was very pleasant but unnexpected.
The remainder of the night, I stayed at this good fellows house nodding off into daydreams of pleasantness and conversing of meaningless things while watching various mind numbing shows on the television untill I was ready to progress back to my own home back to my own existance.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Grades Tracker
Studant Name
Course
Math
English
Arabic
Art
Science
Student Name
Student Grades
Course
status


Artificial Intelligence has both benefits and Dangers associated with it, we will talk about its benefits here
Sometime its benefits outweight the dangers but if spoken truly every new innovation in technology is a danger first to all humans (The First Car was considered witchcraft and its owner a witch who by some bad luck was a woman).
therefore its very hard to get a good opinion on things at first.
But all that aside even with the narrow A I we have developed so far.
it has revolutionized our work in medicine, mechanics, meteological understanding and the list goes on.
Due to lack of awareness about Artificial Intelligence a lot of people dont know about.
And the small amount that do know is due to the film industry.
who do not depict a good image of A.I.
A study done in United Kingdom show this in simple but detailed daigram.
The question was given to more then 2000 adults of various ages and below are the answers that Atomik Reseach got.
Based on that we can assume that a very small number of our society even know about A.I,
Therefore more education in the matter is needed but we all know its at the mercy of the governement of every respective country to do so.
As more and more artificial intelligence is entering into the world, more and more emotional intelligence must enter into leadership. -- Amit Ray, Famous AI Scientist --
Author of Compassionate Artificial Intelligence
The above qoute really shows the reality of the ignorence of the nowadays governement and regulatory authorities in general.
Its true to a fact because they dont care as A I is a field that they think is not important.
so they don't regulate it.
A.I is beneficial as long as we as humans know what we are doing, because it can be debated that guns are beneficial for personel security but if a gun is given to a morally bad person who is known for causing harm to society the consequences are devastating.
so therefore it is important without a doubt to regulate its use in any field.
because if we dont then the figure below describes our human race in a simple way.
In this video Kai Fu Lee (An Artificial Intelligence Expert ) explains the benefits of A.I to Humanity.
The last is probably because if we use it correctly we can increase our knowledge base by Billion folds but if we dont then the last one will come true.
step 5 can be avoided through care full consideration of developement and usage of A.I itself, because technically we are playing GOD here.
which always goes wrong because we are not Gods so mistakes are very easy to make, and especially when we dont know what we are dealing with.
Success in creating AI would be the biggest event in human history.
br
Unfortunately, it might also be the last, unless we learn how to avoid the risks.
-- Stephen Hawking, Famous Theoretical Physicist --
Cosmologist, and Author.
This another great qoute from Dr.Hawking himself.
its true to every word because human error is a massive factor every where and machine on the other hand have very tiny error factor in a job or task. so even if we succeed to make a loyal machine.
our mistakes may cause our demise.


Please select all the ways you would like to hear from OpenEMR:
You can unsubscribe at any time by clicking the link in the footer of our emails. For information about our privacy practices, please visit our website.
We use Mailchimp as our marketing platform. By clicking below to subscribe, you acknowledge that your information will be transferred to Mailchimp for processing. Learn more about Mailchimp's privacy practices here.


Drawing 101
The aim of this little drawing exercise is to to create and display a simple image composed of rectangles and lines — like the one you see on the left.
This version of the exercise is a Swift playground that was created from a markup file (asciidoc) I learned a lot from the excellent Youtube video from fullstack.io.
The tool I am using to convert asciidoc files to playgrounds is a ruby script that calls Asciidoctor to convert the markup into the bundle of files that make up a Swift playground.
The advantage of writing in asciidoc is that the same file can be used to publish in different "media". The file used for this exercise is drawing101.ad. Run the command asciidoctor drawing101.ad to produce drawing101.html. Run the command ad2play drawing101.ad to produce the Swift playground bundle drawing101.playground.
See asciidoctor.org for information on how to use and install asciidoctor. I would like to credit jas whose playground-builder inspired me to write ad2play.
Current version of ad2play: 0.1 (hacked together)


Python for Everybody
Chapter 1
Exercise 1.1
Use any function for which you can evaluate the derivatives analytically, investigate the accuracy of the formulas in Table 1.2 for various values of h.
Summary 1.1
To approximate the derivative numerically, we will utilize five equations based off the Maclaurin Series. The Maclaurin Series of function, f(x), is given by the equation,
Solving the equation above for f' yields,
The above equation assumes the function is accurately described by a linear function over the interval (0,h). This gives the first of the "2-point" methods; the forware 2-point method.
Where x is the value where the derivative is being evaluated and h is the step-sized used. Using the same methods as above but using the previous point produces the equation,
This assumes the function is accurately described by a linear function over the interval (-h,0). Notice each of these equations are accurate up to one order of h. The following are Python functions utilizing each respective 2-point method,
We can improve tha accuracy by including more terms. Using the immediate values forwards and backwards allos for the terms with even-powered values of hto cancel out. Eq. 1 is the quadratic interpolation of the function over the two previous intervals,
Python interpretation of Eq 5. ,
def symmetric3(x, h): #Performs the symmetric 3-point method on the function defined by myFunc #Input: x -- independent variable # h -- step-size #Output: dependent variable return((myFunc(x+h) - myFunc(x-h)) / (2*h))
The final two equations, the "4-point" and "5-point" formulas, are similarly found and include more interactions forwards and backwards to create higher-order approximations of the function over the given interval. They, along with their higher-order derivatives, are given in the Table 2 . The 5-point formula is the five-point stencil in one-dimension.


The Estimates of Provincial Revenue and Expenditure (EPRE) is considered a summary of the departmental Strategic and Performance Plan to a level at which the legislature and the public can engage the provincial departments. It further contains a detailed analysis of departmental receipt and payment performance; covering infrastructure payments; transfers to public entities and local government; personnel numbers and costs; and payments on training. It also provides departments with an opportunity to analyse the various trends and provide a narrative thereto.
One of the key aims of the EPRE is to provide a minimum set of information on receipts, payments, budget and programme structures together with departmental objectives and service delivery measures up to a sub-programme level.
From 2018 onwards, the development of the EPRE has created a standardised budget and programme structure and definitions for the main departmental budgets. Fourteen sectors have agreed upon uniform budget and programme structures, which apart from the Social Services Sectors (Education, Health and Social Development) include: Agriculture; Environmental Affairs; Human Settlements; Cooperative Governance and Traditional Affairs; Public Works; Economic Development; Office of the Premier; Transport; Sport, Arts and Culture; Provincial Legislatures; Tourism and Provincial Treasuries.
The budget process that produces an EPRE is a collaboration that includes National Treasury, Provincial Treasuries, Sector Budget meetings, Technical Committees on Finance, Budget councils, Ministers’ Committees on Budget, Provincial Cabinet management committees, executive councils, provincial departments and public entities. The planning for the following year’s provincial budget starts very shortly after the current year’s budget is presented, and includes budget reviews and stakeholder consultation.
National Treasury has provided a standardised data entry format and budget guidelines for the provinces. The estimation of revenue and expenditure present a valuable research resource and give effect to relevant legislation, which include amongst others the Constitution, Public Finance Management Act and the Right to Access of Information Act. It is for this reason that uniform budget documents are a prerequisite.
The EPREs are normally released in early March within weeks of the publication of the national Budget. The provincial financial year, like the national financial year, starts on April 1 and ends on March 30 of the following year.
The EPRE documents and data can be used to
Vulekamali has annual EPRE information for all provincial departments. The following are available:
The detail pages for a department can be found under the Department Budgets link at the top of the website. You can also search vulekamali to find a department.
The EPRE documents (PDF, Excel, and CSV) include provincial expenditure data using the following classifications:
Expenditure by province and expenditure by vote (department): This refers to the province and the provincial government department. This classification is implicit in the individual PDF files which by their nature refer to just one province and to one vote.
Historically the provinces have used different systems to classify their departments. Some departments (e.g. Provincial Treasury, Education, Health) have had a greater degree of standardisation than others. This should be considered when comparing expenditure before 2018/19.
Expenditure by financial year and by budget phase: This refers to the financial year of the expenditure and the position of that year in the current budget cycle. Expenditure for the years prior to the current budget year will be presented as an audited outcome, expenditure for future years will be presented as a medium term estimate, and so on.
The level 1 economic classification divides all expenditure into four main economic sections: current payments (payments made for operational requirements such as those for compensation of employees and goods and services); transfers and subsidies; payments for capital assets (assets that can be used for more than one year); and payments for financial assets (loans or equity investments in public corporations).
Expenditure by programme and sub-programme: This refers to expenditure by provincial department programmes, which align spending to activities. Expenditure can be tracked to the programme and sub-programme level.
Expenditure by value: This refers to the rand value of the expenditure. Some expenditure items (e.g. adjustments) may overlap or duplicate others, and care should be taken when analysing aggregate expenditures.
Each provincial department’s PDF chapter can be found on Vulekamali on the department detail page. The PDF contains a detailed narrative for each provincial department.
The chapters contain the following sections:
There are two datasets for provincial department expenditure on Vulekamali. The dataset for expenditure by economic classification is available as an Excel sheet and in CSV form, while the dataset for expenditure by programme and sub-programme is available in CSV form.
Expenditure data by economic classification is available for seven years, including the two outer years of the MTEF. Expenditure by programme and sub-programme is available for three years. The fields affected by this are the Financial Year and the Budget Phase fields.
The following fields are common to the two datasets:
The dataset for expenditure by economic classification includes the following fields:
You can visit the Estimates of Provincial Revenue and Expenditure - National Treasury’s main page for provincial budget information.


Across: 1,13. My crocodile tries a trick using logs of 30 as 12 4 (10 7) 6. Scratch bird noise once long intro put in (4) 10. After torrid start, alto arrangement complete (5) 11. Delicates show shortage of use perhaps (9) 12. Wandering six in wrong - no leadership (6) 13. see 1 15. Pinches beds (5) 16. Pest devours new apple, start to finish (9) 19. I came part way around - I have them in hand (9) 21. One proceeds from each of the 19 - e.g. 6 (5) 22,30. Greene's caveat: hour was ripe for a popular hero (7 3 7) 25. Greene's plot for our man with a cigar (6) 27. Explain note in broken printer (9) 28. Send off clue - I dare to return it (5) 29. A great divide, such as between 26 and their largest neighbours (4) 30. see 22 Down: 1. 30 took it and forged team (4) 2. Illustrator of Chinese philosophy about abstentious circle (9) 3. Marches... each is 'Left, Right Left!' arrangement (7) 4. Junior, you will have anxiety without a queen (9) 5. Burdened boy with education (5) 7. Behold! We returned, and I a Nobel Laureate! (5) 8. She set tasks for students (10) 9. Cigar man into wearing fancy label (6) 14. Dashing intent fellow to sing about (10) 17. Building to stage rich drama (9) 18. Great in an anguished state, origin of 30 (9) 20. Actors played man with cigar (6) 21. Order? Evade it! (7) 23. Place of birth? (5) 24. Odd characters come out; compere a she (5) 26. Foxy 4 has a place around 25 (4)


Business Administration, MBA (professional)
for the Master of Business Administration in Business Administration
associate dean: W. Brooke Elliott
email<EMAIL_ADDRESS>department website: https://giesbusiness.illinois.edu/mba
department faculty: https://business.illinois.edu/people/
overview of grad college admissions & requirements: https://grad.illinois.edu/admissions/apply
college website: https://giesbusiness.illinois.edu/
department office: Business Instructional Facility, Room 3019, 515 E. Gregory, Champaign, IL 61820
phone:<PHONE_NUMBER>
The Gies College of Business offers a degree program leading to the Master of Business Administration (M.B.A.) in 3 delivery modes. The traditional full-time MBA and the Professional MBA are offered on the Urbana campus. The residential MBA and Professional MBA programs are no longer accepting applications. The online program is offered for students who need more flexibility in their MBA programs.
All Illinois MBA programs require 72 hours of credit. Students graduate with a Masters of Business Administration from the University of Illinois at Urbana-Champaign. Student transcripts do not vary based upon program format.
The Professional MBA program provides a general management curriculum and focus. The curriculum includes 72 credit hours that are completed over a two and a half year period. This program is designed especially for employed professionals who want to continue working while they pursue the MBA degree.
Graduate Degree Programs in Business Administration
Majors:
Business Administration, MBA (Full-Time)
with optional concentrations: Accountancy, Business Data Analytics, Corporate Governance & International Business, Information Technology & Control, Real Estate, Supply Chain Management
Business Administration, MBA (Professional - part-time)
with optional concentrations: Business Data Analytics, Information Technology & Control, Supply Chain Management
Business Administration, MBA (online-iMBA)
Business Administration, MS
with optional concentrations: Accountancy, Business Data Analytics, Business & Public Policy, Corporate Governance & International Business, Finance, Supply Chain Management
Business Analytics, MS
Management, MS
with optional concentrations: Business Data Analytics, Finance
Technology Management, MS
with optional concentrations: Accountancy, Business Data Analytics, Business & Public Policy, Finance, Information Technology & Control, Supply Chain Management
Business Administration, PhD
Minors:
Information Technology & Control
Corporate Governance & International Business
Supply Chain Management
Concentrations:
Business Data Analytics
Corporate Governance & International Business
Information Technology & Control
Supply Chain Management
Joint Degree Program:
Accountancy, MS (iMSA) & Business Administration, MBA (iMBA)
Admission
Admission to the Illinois Gies MBA is dependent upon an earned undergraduate degree, acceptable scores on the Graduate Management Admission Test (GMAT) or Graduate Record Examination (GRE), two letters of recommendation, professional resume and essays. Applicants whose native language is not English are also required to submit scores from the Test of English as a Foreign Language (TOEFL) or the IELTS. For additional requirements the applicant should refer to the MBA application.
Faculty Research Interests
Faculty research interests are in the areas of marketing, organizational behavior, organization theory, decision sciences, information systems, strategic management, risk analysis, judgment under uncertainty, international business, production and operations management, accounting, economics, entrepreneurship, and finance. The Gies College of Business houses computer facilities, a behavioral science laboratory, and a separate library. The college maintains contacts with industry and government through its Survey Research Laboratory, Illinois Business Consulting, the Academy for Entrepreneurial Leadership and several professional and scholarly journals edited by its faculty.
Scholarships/Financial Aid
The Illinois Gies MBA offers a limited number of merit scholarships to outstanding domestic and international applicants. The merit scholarships are awarded at the time of admission. U.S. citizens and permanent residents may be eligible for federal and private student loans.
for the Master of Business Administration in Business Administration
| Code | Title | Hours |
|---|---|---|
| BADM 508 | Leadership and Teams | 4 |
| ECON 528 | Microeconomics for Business | 4 |
| BADM 520 | Marketing Management | 4 |
| ACCY 500 | Accounting Measurement, Reporting, and Control | 4 |
| BADM 572 | Stat for Mgt Decision Making | 4 |
| BADM 567 | Process Management | 4 |
| BADM 590 | Seminar in Business Admin (Section PMB) | 4 |
| BADM 521 | Marketing Strategy | 4 |
| BADM 573 | Decision Analytics | 4 |
| BADM 593 | Research in Special Fields | 4 |
| ECON 529 | Macroeconomics for Business | 4 |
| FIN 520 | Financial Management | 4 |
| BADM 509 | Managing Organizations | 4 |
| FIN 511 | Investments | 4 |
| BADM 544 | Strategic Management | 4 |
| ACCY 503 | Managerial Accounting | 4 |
| BADM 552 | Legal Aspects of Mgt Decisions | 4 |
| Free electives | 4 | |
| Total Hours | 72 |
Other Requirements1
| Other requirements may overlap | |
| Minimum Hours Required Within the College: | 68 |
| Minimum 500-level Hours Required Overall: | 72 |
| Minimum GPA: | 2.75 |
| 1 | For additional details and requirements refer to the department's graduate curriculum and the Graduate College Handbook. |


{% extends "cpslayout.html" %} {% block title %}Create Profile{% endblock %} {% block body %}
Hey! This is the first time you signed in on this website. In order to proceed we need some extra information from you:
If you don't want to proceed, you can sign out again. {% endblock %}


Your Main Benefits
We are sure that your product, service or event has plenty of
advantages. Tell about them.
Super Fast
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.
Simple & Light
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.
Easy To Use
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.
Customize Ready
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.
Unlimited access
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.
1M earn
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.


Welcome!! to WayFarer Bus Booking service app
WayFarer is a Bus company that helps you Book trip at your comfort place with just a click.Led by a proven team, WayFarer commitment is to build the global leader in Bus industry.
WayFarer is a Bus company that helps you Book trip at your comfort place with just a click.Led by a proven team, WayFarer commitment is to build the global leader in Bus industry.


|
| | RDF (const std::string &storage_type="memory", const std::string &storage_name="OmexMetaStore", const char *storage_options=nullptr, const char *model_options=nullptr) |
| | constructor for RDF class More...
|
| |
|
| ~RDF ()=default |
| | destructor for RDF
|
| |
| | RDF (const RDF &rdf)=delete |
| | copy constructor for RDF class More...
|
| |
|
| RDF (RDF &&rdf) noexcept |
| | move constructor for RDF class
|
| |
| RDF & | operator= (const RDF &rdf)=delete |
| | copy assignment constructor for RDF ojects More...
|
| |
|
RDF & | operator= (RDF &&rdf) noexcept |
| | move assignment operator for RDF
|
| |
|
int | size () const override |
| | returns the number of triples currently present in the RDF graph.
|
| |
| bool | empty () const override |
| | indicator for whether the RDF graph is empty More...
|
| |
|
void | addFromString (const std::string &str, const std::string &syntax="guess") override |
| | non-static variant of RDF::fromString(). Reads rdf into an RDF instance. See RDF::fromString() for argument requirements.
|
| |
| void | addFromUri (const std::string &uri_string, const std::string &syntax="guess") override |
| | non-static counterpart of RDF::fromUri. Downloads and parses rdf from a URI. More...
|
| |
| void | addFromFile (const std::string &filename, const std::string &syntax) override |
| | non-static counter part of RDF::fromFile. Reads rdf from annotations in a file More...
|
| |
| std::string | toString (const std::string &syntax="turtle", const char *mime_type=nullptr, const char *type_uri=nullptr) override |
| | serialize RDF graph to string More...
|
| |
| void | toFile (const std::string &filename, const std::string &syntax="turtle", const char *mime_type=nullptr, const char *type_uri=nullptr) override |
| | Write annotations to file. More...
|
| |
| Editor | toEditor (const std::string &xml, bool generate_new_metaids=false, bool sbml_semantic_extraction=true) override |
| | instantiate an Editor object. More...
|
| |
| Editor * | toEditorPtr (const std::string &xml, bool generate_new_metaids=false, bool sbml_semantic_extraction=true) override |
| | instantiate an Editor object and return a new pointer to it. Memory returned is owned by the caller and needs deleting. More...
|
| |
|
LibrdfModel | getModel () const override |
| |
|
LibrdfStorage | getStorage () const override |
| |
|
int | commitTransaction () const override |
| |
|
int | startTransaction () const override |
| |
|
void * | getTransactionHandle () const override |
| |
|
int | startTransactionWithHandle (void *handle) const override |
| |
|
int | getTransactionRollback () const override |
| |
|
std::string | queryResultsAsString (const std::string &query_str, const std::string &results_syntax) override |
| |
|
ResultsMap | queryResultsAsMap (const std::string &query_str) override |
| |
| std::unordered_map< std::string, std::string > | propagateNamespacesFromParser (const std::vector< std::string > &seen_namespaces) override |
| | compared namespaces seen with namespaces known and ensures models that use a known namespace use that namespace. More...
|
| |
| OmexMetaXmlType | getXmlType () const override |
| | getter for xmlType attribue. More...
|
| |
|
bool | operator== (const RDF &rhs) const |
| |
|
bool | operator!= (const RDF &rhs) const |
| |
| void | setXmlType (OmexMetaXmlType xmlType) override |
| | set the xml type for the current graph. More...
|
| |
|
const std::string & | getRepositoryUri () const override |
| | getter for repository uri which defaults to "http://omex-library.org/"
|
| |
| void | setRepositoryUri (const std::string &repositoryName) override |
| | setter for the repository uri which defaults to "http://omex-library.org/". More...
|
| |
| const std::string & | getArchiveUri () const override |
| | getter for archiveUri attribute. More...
|
| |
| void | setArchiveUri (const std::string &archiveName) override |
| | setter for archiveUri attribute. More...
|
| |
| const std::string & | getModelUri () const override |
| | getter for model uri. More...
|
| |
| void | setModelUri (std::string modelName) override |
| | setter for model uri. More...
|
| |
|
const std::string & | getModelMetaid () override |
| | gets the uri fragment used for model level annotations. This must be a valid metaid in your model and should be attached to a "model" element
|
| |
|
void | setModelMetaid (const std::string &modelMetaid) override |
| | sets the uri fragment used for model level annotations. This must be a valid metaid in your model and should be attached to a "model" element
|
| |
| std::string | getModelLevelAnnotationUri () override |
| | get the full uri for model level annotations. More...
|
| |
| const std::string & | getLocalUri () const override |
| | getter for local uri attribute. More...
|
| |
|
void | addTriple (const Triple &triple) override |
| | add a Triple to the current model
|
| |
|
void | addTriples (Triples &triples) override |
| | add a set of Triples to the current model
|
| |
|
UriHandler & | getUriHandler () override |
| |
|
void | purgeRDFBag () |
| | remove rdf:Bag constructs from the current rdf graph
|
| |
| void | translateVcard () |
| |
|
| static RDF | fromString (const std::string &str, const std::string &syntax="guess") |
| | instantiate an RDF instance and read annotations from a string. This is a static method. More...
|
| |
| static RDF | fromUri (const std::string &uri_string, const std::string &syntax="guess") |
| | parse RDF directly from a uri More...
|
| |
| static RDF | fromFile (const std::string &filename, const std::string &syntax) |
| | read rdf from annotations in a file More...
|
| |
|
static std::ostringstream | listOptions () |
| |
| static bool | equals (RDF *actual, const std::string &expected, const std::string &syntax="turtle", bool verbose=false) |
| | test for equality between More...
|
| |
| static bool | equals (const Triple &actual, const std::string &expected, const std::string &syntax="turtle", bool verbose=false) |
| | test for equality between More...
|
| |
| static bool | equals (Triples &actual, const std::string &expected, const std::string &syntax="turtle", bool verbose=false) |
| | test for equality between More...
|
| |
| static bool | equals (RDF *actual, RDF *expected, const std::string &syntax="turtle", bool verbose=false) |
| | test for equality between More...
|
| |
| static bool | equals (const std::string &first, const std::string &second, const std::string &first_syntax="turtle", const std::string &second_syntax="turtle", bool verbose=false) |
| | test for equality between More...
|
| |


[gecode-users] Not all solutions, BAB vs. DFS
Martin Kreißig
martin.kreissig at lss.uni-stuttgart.de
Fri Sep 4 09:06:05 CEST 2009
Hello,
I found out, that GECODe is a very good (if not the best) solution to my problem.
The thing is, that I never used C++ before - everybody has to start at a point ;)
So far I got used to it, but now - when finished - I don't get all solutions of my problem.
Searching in this list I found out that I have to use the BAB search and add the option opt.solutions(0)...
The program worked with DFS before.
But now I get the error:
"terminate called after throwing an instance of 'Gecode::SpaceConstrainUndefined' what(): Space::constrain: Attempt to use undefined constrain function"
My implementation does not follow the syntax given in the examples, like:
"Script::run<Money,DFS,Options>(opt);"
I am starting the search by this:
DFS<CSP> dfs( csp_obj );
So my question is - maybe a bit of a beginner one - this is not possible
with BAB?
How can I add the options variable in this implementation? BAB<CSP>
dfs( csp_obj, opt ); is not working.
In my code I create an IntVarArray in which I have different sets
related to different variables and constrain them by some equations.
Thanks for any comments.
Martin Kreißig
Universität Stuttgart
Lehrstuhl für Systemtheorie und Signalverarbeitung
More information about the gecode-users
mailing list


The following is a co-post from The Daily Riff on what a good flipped classroom looks like:
The Flipped Class
What Does a Good One Look Like?
“The classroom environment and learning culture play
a large role in determining the best pedagogical strategy.”
by Brian Bennett, Jason Kern, April Gudenrath and Philip McIntosh
The idea of the flipped class started with lecture and direct instruction being done at home via video and/or audio, and what was once considered homework is done in class. So, the order of the “lecture” and “homework” components of the class are, well — flipped.
Now, it is becoming much more than that.
The main reason, maybe the only reason, to flip a class is to provide more class time for learning and that is the major shift that we are seeing as the flip gains popularity across content areas. Other than that, a good flipped class should be like any other in which good teaching and effective learning take place. Flipping the class is not the end-all solution to finding the “best use” of class time, but it does allow for varied forms of instruction. And after all, doesn’t anything that results in more in-class learning a move in the right direction?
A lot of flipped class discussions focus on moving away from a traditional lecture format. While some lessons lend themselves better to a lecture format, others will be more appropriate as a flipped lesson. The classroom environment and learning culture play a large role in determining the best pedagogical strategy. This decision-making is a vital part of providing a constructive learning environment for students.
Switching from a traditional classroom to a flipped classroom can be daunting because there are a lack of effective models. So, what should an effective flipped classroom look like? In our experience, effective flipped classrooms share many of these characteristics:
The flipped class is not for everyone, but it offers the best way we know of to maximize in-class learning opportunities. If an individual learner or group of learners needs something akin to lecture, that can be done. Small group discussions? No problem. Plenty of time for interaction with the teacher? You bet.
The best way to understand how the method works is to see it in action. If you are interested in the Flipped Classroom, you are not alone…find and begin building a support network at The Flipped Class Network. Look at the network resources, connect with other professionals, or even visit a class and see what the buzz is about. Chances are the flip will be coming soon to a school near you, if it hasn’t already.
—-
Once again, we recognize that the flipped class does not and cannot end with the flip itself. You, as a teacher, have to make intentional decisions about how to best meet the needs of your students. It might begin with videos, but it might (and probably should) move away from them as you and your learners figure out how they learn best. There is no one “correct” model of a flipped classroom. If you ask me, I would say a “flipped” class is one where the majority of class time is spent working collaboratively and intentionally to give learners a chance to explore, explain, and create content.
The vocabulary and title of the class are the biggest talking points. Let’s stop focusing on the title of the class and start talking about all the opportunities students have in school, wether its in a “flipped” class or not.
Written on June 24th, 2011 by Brian Bennett Categorized in: All Flipclass
Leave a comment


First post on portfolio optimization from a quantitative finance lense.
We are optimizing a portfolio with N assets, where \(N \geq 2\) (N is a positive integer)
Definition 1 The weight of each assets i in the portfolio is defined as:
\[ W_i = \frac{\mbox{Market value of asset i}}{\mbox{Total market value of portfolio}} \tag{1}\]
Of course, the sum of all the weights should be equal to 1.
\[\sum_{i = 1}^{N} W_i = 1 \tag{2}\]
Few assumptions made on the assets.
- each asset has an expected return denoted by \(\mu_i \mbox{ with } i = 1, 2, \ldots, N\). In that sense \(\mu_i = E[R_i]\)
- each asset has standard deviation on their returns denotated by \(\sigma_i \mbox{ with } i = 1, 2, \ldots, N\)
- the correlation between asset i and asset j is denoted by \(\rho_{ij} \mbox{ with } i,j = 1, 2, \ldots, N\). In that sense, \(\rho_{ij} = corr(R_i, R_j)\)
The Mean-Variance Optimization problem can be formulated in 2 ways:
- Highest possible returns for a given amount of risk
- Lowest possible amount of risk for a given expected return
Return is the expected return of the asset and risk is the variance of the returns of the asset.
The Risk-Free Asset (RFA) is the money deposited in a bank account-ish (a secure term-deposit) at a fixed rate R. The expected return is thus R and volatitliy is 0. Also the correlation between the RFA and any other assets is 0.
Each asset can be represented on a 2D-plane with the risk on the x-axis and returns on the y-axis.
There are some other assumptions made when trying to construct a mean-variance optimum portfolio:
- results are based on total returns (include dividends, interest paid, etc.)
- fractional shares are possible
- can deposit and withdraw money freely at the risk-free rate
- no restriction on short selling
- doesn’t account for tax, transaction fees, collateral and margins.
In practice
To bring these idea into practices, there are a few ways to go about it. The first approach is to have Monte-Carlo simulations using historical data for the parameters of the mean and variance. Another approach would be to use numerical methods to find the optimum weights that maximize the sharpe ratio (aka ratio of returns to volatility). In this way, we’ll find the efficient frontier: aka the best returns for a given risk or a lowest risk for a given returns.
Create MC simulations of weights to assess mean-variance of a portfolio
Let’s get 5 different financial assets: AA, LLY, AMD, SBUX, FDX. Although they are from different industries, it is not a very diverse bunch as they are all from US big companies.
We already have the assets downloaded and we’ll use their closing prices.
library(readr) # read_csv()
library(dplyr) # select(), arrange(), filter(), mutate(), summarize()
library(purrr) # map()
library(tidyr) # drop_na(), pivot_wider(), unnest()
library(glue) # glue()
library(lubridate)
# read adjusted closing prices and compute annualized daily returns and sd
<- function(ticker) {
read_prices <- read_csv(glue('../../raw_data/', {ticker}, '.csv')) |>
df arrange(date) |>
select(date, adj_close = adjClose) |>
filter(date > '2018-01-01') |>
mutate(ret1d = (adj_close / lag(adj_close, 1)) - 1) |>
summarize(mean_ret = mean(ret1d, na.rm = T) * 252 * 100,
std_ret = sd(ret1d, na.rm = T) * sqrt(252) * 100)
}
<- c('AA', 'LLY', 'AMD', 'SBUX', 'FDX')
assets <- tibble(ticker = assets,
df prices = map(ticker, read_prices)) |>
unnest()
| Ticker | Mean Ret | Std of Ret |
|---|---|---|
| AA | 15.90 | 60.72 |
| LLY | 31.79 | 29.78 |
| AMD | 55.20 | 56.37 |
| SBUX | 16.43 | 30.36 |
| FDX | 4.40 | 37.53 |
First, we create the df of returns:
- it’s a long df with only ticker, date, daily returns
- one row per daily observation.
- we drop first row with no returns
- the returns df is a wide df with date and tickers as columns, then daily returns as row
# functions to get daily returns of each assets
<- function(ticker) {
create_returns_df <- read_csv(glue('../../raw_data/', {ticker}, '.csv')) |>
df arrange(date) |>
select(date, adj_close = adjClose) |>
filter(date > '2018-01-01') |>
mutate(ret1d = (adj_close / lag(adj_close, 1)) - 1) |>
select(date, ret1d)
}
# df of each assets and all their daily returns
<- tibble(ticker = assets,
df prices = map(ticker, create_returns_df)) |>
unnest(cols = c(prices)) |>
drop_na()
<- df |> arrange(ticker) |>
returns pivot_wider(names_from = ticker, values_from = ret1d)
head(returns)
# A tibble: 6 × 6
date AA AMD FDX LLY SBUX
<date> <dbl> <dbl> <dbl> <dbl> <dbl>
1 2018-01-03 -0.0121 0.0519 0.0125 0.00543 0.0187
2 2018-01-04 0.00367 0.0494 0.0156 0.00446 0.00375
3 2018-01-05 -0.0112 -0.0198 0.00393 0.0123 0.0115
4 2018-01-08 0.0168 0.0337 0.0103 -0.00508 -0.00503
5 2018-01-09 -0.0145 -0.0375 -0.00339 -0.000813 -0.00219
6 2018-01-10 0.0363 0.0118 0.000971 0.000465 0.0108
To optimize the mean-variance of the portfolio, we consider the following
Weights of each assets are \(w = \pmatrix{w_1 \\ w_2 \\ \vdots \\ w_n}\).
Mean returns of each assets are \(\mu = \pmatrix{\mu_1 \\ \mu_2 \\ \vdots \\ \mu_n}\)
Then, the expected portfolio return is \(\mu_{\pi} = w^{T} \cdot \mu\) where \(w^{T}\) is the transpose of \(w\) (aka transforming \(w\) from a column vector to a row vector in order to have right dimensions to compute the dot product).
And the expected portfolio variance is computed by \[\sigma_{\pi}^2 = w^T \cdot \Sigma \cdot w\] where \(\Sigma\) is the covariance matrix. Also, don’t forget to square root the variance when using sd: \(\sigma_{\pi} = \sqrt{w^T \cdot \Sigma \cdot w}\)
To put this into code, we first create the matrix of returns,then create the covariance matrix. Using both matrices, we create a function that return the portfolio mean and variance using the randomly chosen weights.
# this df to provide vectors of expected returns
<- df |>
df_stat group_by(ticker) |>
summarize(mean_ret = mean(ret1d, na.rm = T) * 252) |>
ungroup() |> arrange(ticker)
= as.matrix(df_stat$mean_ret, nrow = length(assets))
mu
# this df to provide the covariance matrix
# note how we have also multiplied it by 252
<- df |> arrange(ticker) |>
sigma pivot_wider(names_from = ticker, values_from = ret1d) |>
drop_na() |>
select(-date) |> cov() * 252
<- as.matrix(sigma, nrow = length(assets))
sigma
# this function to create one simulation using random weights
<- function(n) {
create_one_portfolio_simulation # pick random weights
= runif(length(assets))
weights_rand = matrix(weights_rand / sum(weights_rand), nrow = length(assets))
weights
#these are textbook formula for return and volat of a portfolio
= as.numeric(t(weights) %*% mu)
return_pi = sqrt(as.numeric((t(weights) %*% sigma) %*% weights))
volat_pi = return_pi / volat_pi
sharpe_ratio
# wrap everything into a df for later checks / analysis
<- tibble(portf_ret = round(return_pi * 100, 4), portf_volat = round(volat_pi * 100, 4),
df weights = round(t(weights) * 100, 4), sharpe_ratio = sharpe_ratio)
return(df)
}
#this is really the only inputs to get
= 7000
num_portfolio
= tibble(id = 1:num_portfolio) |>
mc_simu mutate(simul = map(id, create_one_portfolio_simulation)) |>
unnest(cols=c(simul)) |>
arrange(desc(sharpe_ratio))
head(mc_simu)
# A tibble: 6 × 5
id portf_ret portf_volat weights[,1] [,2] [,3] [,4] [,5] sharpe_ratio
<int> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
1 5710 37.8 29.4 0.168 31.1 0.757 61.6 6.43 1.29
2 6227 34.7 27.6 0.937 25.3 0.648 55.8 17.2 1.26
3 483 34.8 27.9 0.917 26.1 5.59 58.2 9.18 1.25
4 184 37.6 30.3 0.546 35.6 6.66 53.1 4.14 1.24
5 3169 36.0 29.1 1.90 32.0 4.07 50.2 11.9 1.24
6 1388 34.1 27.5 3.26 18.0 4.97 73.4 0.415 1.24
Vizualisation of mean-variances points
We have highlithed the portfolio with best mean-variance returns with a red square around its dot.
library(ggplot2)
ggplot(mc_simu, aes(x = portf_volat, y = portf_ret)) +
geom_point(aes(colour = sharpe_ratio)) +
scale_color_distiller(palette="Set1") +
geom_point(data = mc_simu[1,], aes(x = portf_volat, y = portf_ret),
color = 'red', size = 6, shape=5) +
xlab('Portfolio Volatility') +
ylab('Portfolio Returns') +
labs(title = 'MC simulation for 5 stocks', color = 'Sharpe \n Ratio')


docker login
説明
Docker Registry にログインします。
利用方法
docker login [オプション] [SERVER]
本コマンドの利用例については、以下に示す 利用例の節 を参照してください。
オプション
| 名前／省略形 | デフォルト | 説明 |
--password , -p |
パスワード。 | |
--password-stdin |
標準入力からパスワードを指定します。 | |
--username , -u |
ユーザー名。 |
利用例
Login to a self-hosted registry
If you want to login to a self-hosted registry you can specify this by adding the server name.
$ docker login localhost:8080
STDIN からのパスワード入力
To run the docker login
command non-interactively, you can set the
--password-stdin
flag to provide a password through STDIN
. Using
STDIN
prevents the password from ending up in the shell’s history,
or log-files.
The following example reads a password from a file, and passes it to the
docker login
command using STDIN
:
$ cat ~/my_password.txt | docker login --username foo --password-stdin
Privileged user requirement
docker login
requires user to use sudo
or be root
, except when:
- connecting to a remote daemon, such as a
docker-machine
provisioneddocker engine
. - user is added to the
docker
group. This will impact the security of your system; thedocker
group isroot
equivalent. See Docker Daemon Attack Surface for details.
You can log into any public or private repository for which you have
credentials. When you log in, the command stores credentials in
$HOME/.docker/config.json
on Linux or %USERPROFILE%/.docker/config.json
on
Windows, via the procedure described below.
Credentials store
The Docker Engine can keep user credentials in an external credentials store, such as the native keychain of the operating system. Using an external store is more secure than storing credentials in the Docker configuration file.
To use a credentials store, you need an external helper program to interact
with a specific keychain or external store. Docker requires the helper
program to be in the client’s host $PATH
.
This is the list of currently available credentials helpers and where you can download them from:
- D-Bus Secret Service: https://github.com/docker/docker-credential-helpers/releases
- Apple macOS keychain: https://github.com/docker/docker-credential-helpers/releases
- Microsoft Windows Credential Manager: https://github.com/docker/docker-credential-helpers/releases
- pass: https://github.com/docker/docker-credential-helpers/releases
Configure the credentials store
You need to specify the credentials store in $HOME/.docker/config.json
to tell the docker engine to use it. The value of the config property should be
the suffix of the program to use (i.e. everything after docker-credential-
).
For example, to use docker-credential-osxkeychain
:
{
"credsStore": "osxkeychain"
}
If you are currently logged in, run docker logout
to remove
the credentials from the file and run docker login
again.
Default behavior
By default, Docker looks for the native binary on each of the platforms, i.e. “osxkeychain” on macOS, “wincred” on windows, and “pass” on Linux. A special case is that on Linux, Docker will fall back to the “secretservice” binary if it cannot find the “pass” binary. If none of these binaries are present, it stores the credentials (i.e. password) in base64 encoding in the config files described above.
Credential helper protocol
Credential helpers can be any program or script that follows a very simple protocol. This protocol is heavily inspired by Git, but it differs in the information shared.
The helpers always use the first argument in the command to identify the action.
There are only three possible values for that argument: store
, get
, and erase
.
The store
command takes a JSON payload from the standard input. That payload carries
the server address, to identify the credential, the user name, and either a password
or an identity token.
{
"ServerURL": "https://index.docker.io/v1",
"Username": "david",
"Secret": "passw0rd1"
}
If the secret being stored is an identity token, the Username should be set to
<token>
.
The store
command can write error messages to STDOUT
that the docker engine
will show if there was an issue.
The get
command takes a string payload from the standard input. That payload carries
the server address that the docker engine needs credentials for. This is
an example of that payload: https://index.docker.io/v1
.
The get
command writes a JSON payload to STDOUT
. Docker reads the user name
and password from this payload:
{
"Username": "david",
"Secret": "passw0rd1"
}
The erase
command takes a string payload from STDIN
. That payload carries
the server address that the docker engine wants to remove credentials for. This is
an example of that payload: https://index.docker.io/v1
.
The erase
command can write error messages to STDOUT
that the docker engine
will show if there was an issue.
Credential helpers
Credential helpers are similar to the credential store above, but act as the
designated programs to handle credentials for specific registries. The default
credential store (credsStore
or the config file itself) will not be used for
operations concerning credentials of the specified registries.
Configure credential helpers
If you are currently logged in, run docker logout
to remove
the credentials from the default store.
Credential helpers are specified in a similar way to credsStore
, but
allow for multiple helpers to be configured at a time. Keys specify the
registry domain, and values specify the suffix of the program to use
(i.e. everything after docker-credential-
).
For example:
{
"credHelpers": {
"registry.example.com": "registryhelper",
"awesomereg.example.org": "hip-star",
"unicorn.example.io": "vcbait"
}
}
上位コマンド
| コマンド | 説明 |
|---|---|
| docker | Docker CLI の基本コマンド |


I am small
I have more content than the very small item.
I have lots of content. So much content that I don't know where it is all going to go. I'm glad that CSS is pretty good at dealing with situations where we end up with more words than expected!
ul { } li { }
I am small
I have more content than the very small item.
I have lots of content. So much content that I don't know where it is all going to go. I'm glad that CSS is pretty good at dealing with situations where we end up with more words than expected!


Recepient data Recepient data is required
City City is required
Country Country is required
Address Address is required
Postal code Postal code is required


2 Corinthians 7:15
And his inward affection is more abundant toward you, whilst he remembereth the obedience of you all, how with fear and trembling ye received him.


Gain access to Autodesk products and services with a single set of credentials.
Your account is what you use for everything you do with Autodesk
products and services, such as Fusion, A360, Sketchbook, 123d App, Store
and much more.
With just one account, you can sign into all
your Autodesk entitlements and get access to new ones.
Access and update your marketing subscriptions, and language preferences
for Autodesk products and services.
Need to update your contact email? Just head into your account and
make the necessary updates to your profile.
Because your security is our utmost priority here at
Autodesk,
we allow updating any of your access credentials at
any point of time should you feel that your account has been
compromised.
In addition, we offer enhanced security features
to help you feel secure with your account.
Sign in with


|
Plotly
Interactive Python library for graphing
|
Functions | |
| def | check_bar_match (old_bar, new_bar) |
| def | check_corners (inner_obj, outer_obj) |
| def | convert_dash (mpl_dash) |
| def | convert_path (path) |
| def | convert_symbol (mpl_symbol) |
| def | hex_to_rgb (value) |
| def | merge_color_and_opacity (color, opacity) |
| def | convert_va (mpl_va) |
| def | convert_x_domain (mpl_plot_bounds, mpl_max_x_bounds) |
| def | convert_y_domain (mpl_plot_bounds, mpl_max_y_bounds) |
| def | display_to_paper (x, y, layout) |
| def | get_axes_bounds (fig) |
| def | get_axis_mirror (main_spine, mirror_spine) |
| def | get_bar_gap (bar_starts, bar_ends, tol=1e-10) |
| def | convert_rgba_array (color_list) |
| def | convert_path_array (path_array) |
| def | convert_linewidth_array (width_array) |
| def | convert_size_array (size_array) |
| def | get_markerstyle_from_collection (props) |
| def | get_rect_xmin (data) |
| def | get_rect_xmax (data) |
| def | get_rect_ymin (data) |
| def | get_rect_ymax (data) |
| def | get_spine_visible (ax, spine_key) |
| def | is_bar (bar_containers, **props) |
| def | make_bar (**props) |
| def | prep_ticks (ax, index, ax_type, props) |
| def | prep_xy_axis (ax, props, x_bounds, y_bounds) |
| def | mpl_dates_to_datestrings (dates, mpl_formatter) |
Variables | |
| DASH_MAP | |
| PATH_MAP | |
| SYMBOL_MAP | |
| VA_MAP | |
Tools A module for converting from mpl language to plotly language.
| def plotly.matplotlylib.mpltools.check_bar_match | ( | old_bar, | |
| new_bar | |||
| ) |
Check if two bars belong in the same collection (bar chart). Positional arguments: old_bar -- a previously sorted bar dictionary. new_bar -- a new bar dictionary that needs to be sorted.
| def plotly.matplotlylib.mpltools.convert_dash | ( | mpl_dash | ) |
Convert mpl line symbol to plotly line symbol and return symbol.
| def plotly.matplotlylib.mpltools.convert_symbol | ( | mpl_symbol | ) |
Convert mpl marker symbol to plotly symbol and return symbol.
| def plotly.matplotlylib.mpltools.convert_va | ( | mpl_va | ) |
Convert mpl vertical alignment word to equivalent HTML word. Text alignment specifiers from mpl differ very slightly from those used in HTML. See the VA_MAP for more details. Positional arguments: mpl_va -- vertical mpl text alignment spec.
| def plotly.matplotlylib.mpltools.convert_x_domain | ( | mpl_plot_bounds, | |
| mpl_max_x_bounds | |||
| ) |
Map x dimension of current plot to plotly's domain space. The bbox used to locate an axes object in mpl differs from the method used to locate axes in plotly. The mpl version locates each axes in the figure so that axes in a single-plot figure might have the bounds, [0.125, 0.125, 0.775, 0.775] (x0, y0, width, height), in mpl's figure coordinates. However, the axes all share one space in plotly such that the domain will always be [0, 0, 1, 1] (x0, y0, x1, y1). To convert between the two, the mpl figure bounds need to be mapped to a [0, 1] domain for x and y. The margins set upon opening a new figure will appropriately match the mpl margins. Optionally, setting margins=0 and simply copying the domains from mpl to plotly would place axes appropriately. However, this would throw off axis and title labeling. Positional arguments: mpl_plot_bounds -- the (x0, y0, width, height) params for current ax ** mpl_max_x_bounds -- overall (x0, x1) bounds for all axes ** ** these are all specified in mpl figure coordinates
| def plotly.matplotlylib.mpltools.convert_y_domain | ( | mpl_plot_bounds, | |
| mpl_max_y_bounds | |||
| ) |
Map y dimension of current plot to plotly's domain space. The bbox used to locate an axes object in mpl differs from the method used to locate axes in plotly. The mpl version locates each axes in the figure so that axes in a single-plot figure might have the bounds, [0.125, 0.125, 0.775, 0.775] (x0, y0, width, height), in mpl's figure coordinates. However, the axes all share one space in plotly such that the domain will always be [0, 0, 1, 1] (x0, y0, x1, y1). To convert between the two, the mpl figure bounds need to be mapped to a [0, 1] domain for x and y. The margins set upon opening a new figure will appropriately match the mpl margins. Optionally, setting margins=0 and simply copying the domains from mpl to plotly would place axes appropriately. However, this would throw off axis and title labeling. Positional arguments: mpl_plot_bounds -- the (x0, y0, width, height) params for current ax ** mpl_max_y_bounds -- overall (y0, y1) bounds for all axes ** ** these are all specified in mpl figure coordinates
| def plotly.matplotlylib.mpltools.display_to_paper | ( | x, | |
| y, | |||
| layout | |||
| ) |
Convert mpl display coordinates to plotly paper coordinates. Plotly references object positions with an (x, y) coordinate pair in either 'data' or 'paper' coordinates which reference actual data in a plot or the entire plotly axes space where the bottom-left of the bottom-left plot has the location (x, y) = (0, 0) and the top-right of the top-right plot has the location (x, y) = (1, 1). Display coordinates in mpl reference objects with an (x, y) pair in pixel coordinates, where the bottom-left corner is at the location (x, y) = (0, 0) and the top-right corner is at the location (x, y) = (figwidth*dpi, figheight*dpi). Here, figwidth and figheight are in inches and dpi are the dots per inch resolution.
| def plotly.matplotlylib.mpltools.get_axes_bounds | ( | fig | ) |
Return the entire axes space for figure. An axes object in mpl is specified by its relation to the figure where (0,0) corresponds to the bottom-left part of the figure and (1,1) corresponds to the top-right. Margins exist in matplotlib because axes objects normally don't go to the edges of the figure. In plotly, the axes area (where all subplots go) is always specified with the domain [0,1] for both x and y. This function finds the smallest box, specified by two points, that all of the mpl axes objects fit into. This box is then used to map mpl axes domains to plotly axes domains.
| def plotly.matplotlylib.mpltools.get_rect_xmax | ( | data | ) |
Find maximum x value from four (x,y) vertices.
| def plotly.matplotlylib.mpltools.get_rect_xmin | ( | data | ) |
Find minimum x value from four (x,y) vertices.
| def plotly.matplotlylib.mpltools.get_rect_ymax | ( | data | ) |
Find maximum y value from four (x,y) vertices.
| def plotly.matplotlylib.mpltools.get_rect_ymin | ( | data | ) |
Find minimum y value from four (x,y) vertices.
| def plotly.matplotlylib.mpltools.get_spine_visible | ( | ax, | |
| spine_key | |||
| ) |
Return some spine parameters for the spine, `spine_key`.
| def plotly.matplotlylib.mpltools.hex_to_rgb | ( | value | ) |
Change a hex color to an rgb tuple :param (str|unicode) value: The hex string we want to convert. :return: (int, int, int) The red, green, blue int-tuple. Example: '#FFFFFF' --> (255, 255, 255)
| def plotly.matplotlylib.mpltools.is_bar | ( | bar_containers, | |
| ** | props | ||
| ) |
A test to decide whether a path is a bar from a vertical bar chart.
| def plotly.matplotlylib.mpltools.make_bar | ( | ** | props | ) |
Make an intermediate bar dictionary. This creates a bar dictionary which aids in the comparison of new bars to old bars from other bar chart (patch) collections. This is not the dictionary that needs to get passed to plotly as a data dictionary. That happens in PlotlyRenderer in that class's draw_bar method. In other words, this dictionary describes a SINGLE bar, whereas, plotly will require a set of bars to be passed in a data dictionary.
| def plotly.matplotlylib.mpltools.merge_color_and_opacity | ( | color, | |
| opacity | |||
| ) |
Merge hex color with an alpha (opacity) to get an rgba tuple. :param (str|unicode) color: A hex color string. :param (float|int) opacity: A value [0, 1] for the 'a' in 'rgba'. :return: (int, int, int, float) The rgba color and alpha tuple.
| def plotly.matplotlylib.mpltools.mpl_dates_to_datestrings | ( | dates, | |
| mpl_formatter | |||
| ) |
Convert matplotlib dates to iso-formatted-like time strings. Plotly's accepted format: "YYYY-MM-DD HH:MM:SS" (e.g., 2001-01-01 00:00:00) Info on mpl dates: http://matplotlib.org/api/dates_api.html
| def plotly.matplotlylib.mpltools.prep_ticks | ( | ax, | |
| index, | |||
| ax_type, | |||
| props | |||
| ) |
Prepare axis obj belonging to axes obj. positional arguments: ax - the mpl axes instance index - the index of the axis in `props` ax_type - 'x' or 'y' (for now) props - an mplexporter poperties dictionary


Put, Get and Remove some content from execContext
${instruction-counter}. Edit the index.html page and add the following content
This is the value stored for a_key
""
""
Stores a value for "a_key" into the execContext using axel:put then uses axel:get to retrieve it, then uses axel:remove to remove it.
${instruction-counter}. Refresh the browser and now you see the new content showing the results.
This is the value stored for a_key
""
""
The first axel:get returns "This is the value stored for a_key", then the a_key is removed and the 2nd axel:get returns "null"


Payable Edit
Payee
Please select ...
Due Date (M/d/yyyy)
Amount Due
Previous Balance
Previous Payments
Statement Date (M/d/yyyy)
Minimum Payment
Save


A DataTable represents the data that will be visualized in a chart.
Google Chart Tools uses a table-format as data-storage. The actual function of the table's head and cells depends on the chart the data is used for (e. g. in pie-charts, a table with two rows is used where the first column represents the slices' label. The second column is used as the slices' value).
The DataTable is divided into a column-definition (the table's header) and rows. By the column definition, the column's value-type (string, number, etc.) is specified and the data (that will be visualized) is stored in the rows.
Example: Lets assume the table below should be stored in a DataTable.
|----------------|-----------------------| | Name: Task | Name: Hours per Day | | Type: string | Type: Number | |----------------|-----------------------| | Work | 11 | | Eat | 2 | | Commute | 2 | | Watch TV | 2 | | Sleep | 7 | |----------------|-----------------------|
This table will be represented by the DataTable through the following code:
You will find detailed information on how many columns are supported by a specific chart, their purpose etc. in detail at the corresponding chart's subpage published at https://google-developers.appspot.com/chart/interactive/docs/gallery.
Located in /googlecharttools/model/DataTable.class.php (line 88)
Adds a new column definition to the table.
Fills the DataTable by reading an associative array.
Every element of the array will be seen as a new row whereby the array's keys are used for the first column and the array's values for the second column. Thus, this will require a DataTable with two columns only.
Gets all columns that have been added to the DataTable.
Gets the number of columns that have been added to the DataTable.
Gets all rows that have been added to the DataTable.
Gets the number of rows that have been added to the DataTable.
Converts this object into a JSON-object.
This representation follows the JavaScript literal format specified at https://google-developers.appspot.com/chart/interactive/docs/reference#dataparam.
Documentation generated on Mon, 01 Oct 2012 16:45:05 +0200 by phpDocumentor 1.4.4


ASP.Net Core
MVC
Differences from .net 4.5/MVC 5
Core/net5/net6 has changed design several times
- Project
- Revised (minimal) version of csproj, including PackageReference(nuget) Pre 2016 it was xproj and project.json
- References are now Nuget packages (dependencies in project.json csproj)
- No global.asax
- Core/net5: program.cs and startup.cs
- net6: program.cs
- It is multi-platform (linux servers/containers).
- Asp
- No Asp lifecycle events- it has OWIN type middleware
- You can't just deploy the asp project folder. The web root is now the wwwroot folder. You need to Publish (to Release/publish folder) which puts the web.config/exe/dlls top and copies wwwroot below.
- No bundling - use LigerShark.WebOptimizer.Core or gulp instead
- Front-end resources (jquery etc) are not nuget any more.
- Dependency injection is pervasive (not service-locator as before)
- MVC and WebApi are the same now, not parallel frameworks with misleading similarities (2 different AuthorizeAttributes)
- Less IIS. For core 2 you used kestrel to IIS, but we're back in IIS now.
- A minimal, static web.config. All configuration settings are via the configuration system- environment variables, json files..


> You will be given a random target score at the beginning of the game.
> There are four different color gems to choose from. By clicking on any of the four gems you will add a random amount to your current score.
> The value of each gem is hidden from you until you click it and it will change each game.
> You win the game by matching your score to the target score. If you go over the target score you lose.
> The values of each gem will change each time a new round starts.


A globbing fs.watch wrapper built from the best parts of other fine watch libs.
Compatible with Node.js 4.x/0.12/0.10, Windows, OSX and Linux.
Install the module with: npm install gaze
or place into your package.json
and run npm install
.
var gaze = require('gaze');
// Watch all .js files/dirs in process.cwd()
gaze('**/*.js', function(err, watcher) {
// Files have all started watching
// watcher === this
// Get all watched files
var watched = this.watched();
// On file changed
this.on('changed', function(filepath) {
console.log(filepath + ' was changed');
});
// On file added
this.on('added', function(filepath) {
console.log(filepath + ' was added');
});
// On file deleted
this.on('deleted', function(filepath) {
console.log(filepath + ' was deleted');
});
// On changed/added/deleted
this.on('all', function(event, filepath) {
console.log(filepath + ' was ' + event);
});
// Get watched files with relative paths
var files = this.relative();
});
// Also accepts an array of patterns
gaze(['stylesheets/*.css', 'images/**/*.png'], function() {
// Add more patterns later to be watched
this.add(['js/*.js']);
});
var Gaze = require('gaze').Gaze;
var gaze = new Gaze('**/*');
// Files have all started watching
gaze.on('ready', function(watcher) { });
// A file has been added/changed/deleted has occurred
gaze.on('all', function(event, filepath) { });
gaze('**/*', function(error, watcher) {
if (error) {
// Handle error if it occurred while starting up
}
});
// Or with the alternative interface
var gaze = new Gaze();
gaze.on('error', function(error) {
// Handle error here
});
gaze.add('**/*');
See isaacs's minimatch for more information on glob patterns.
patterns
{String|Array} File patterns to be matchedoptions
{Object}callback
{Function}
err
{Error | null}watcher
{Object} Instance of the Gaze watcherCreate a Gaze object by instancing the gaze.Gaze
class.
var Gaze = require('gaze').Gaze;
var gaze = new Gaze(pattern, options, callback);
options
The options object passed in.
interval
{integer} Interval to pass to fs.watchFiledebounceDelay
{integer} Delay for events called in succession for the same
file/event in millisecondsmode
{string} Force the watch mode. Either 'auto'
(default), 'watch'
(force native events), or 'poll'
(force stat polling).cwd
{string} The current working directory to base file patterns from. Default is process.cwd()
.ready(watcher)
When files have been globbed and watching has begun.all(event, filepath)
When an added
, changed
or deleted
event occurs.added(filepath)
When a file has been added to a watch directory.changed(filepath)
When a file has been changed.deleted(filepath)
When a file has been deleted.renamed(newPath, oldPath)
When a file has been renamed.end()
When the watcher is closed and watches have been removed.error(err)
When an error occurs.nomatch
When no files have been matched.emit(event, [...])
Wrapper for the EventEmitter.emit.
added
|changed
|deleted
events will also trigger the all
event.close()
Unwatch all files and reset the watch instance.add(patterns, callback)
Adds file(s) patterns to be watched.remove(filepath)
removes a file or directory from being watched. Does not
recurse directories.watched()
Returns the currently watched files.relative([dir, unixify])
Returns the currently watched files with relative paths.
dir
{string} Only return relative files for this directory.unixify
{boolean} Return paths with /
instead of \\
if on Windows.Other great watch libraries to try are:
In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using grunt.
<EMAIL_ADDRESS>with minimatch >= 3.0.0
.maxListeners
. Update globule to 0.2.0
.relative()
and watched()
. Better error handling. Update to<EMAIL_ADDRESS>No longer watches cwd
by default. Added mode
option. Better EMFILE
message. Avoids ENOENT
errors with symlinks. All constructor arguments are optional.end
before removeAllListeners.forceWatchMethod
option removed, bug fixes and watch optimizations (@rgaskill).added
events in current working dir.path.sep
. Add forceWatchMethod
option. Support renamed
events.cwd
option properlyCopyright (c) 2015 Kyle Robinson Young
Licensed under the MIT license.


Malaysia
Tirath Ramdas is the founder and advisor of the Big Data Malaysia professional network; a non-profit network dedicated to evangelizing Big Data in Malaysia. The network adopts a very broad view of Big Data, encompassing issues such as data journalism and open data. In August, the network organized an event in Kuala Lumpur called the ‘Open Data: Pathways for Applying Big Data for Public Service’.
Malaysia ranked #112 in the 2014 Open Data Index / Other stories from Asia/Pacific
2014 has been an important year for Open Data in Malaysia. In June, the Prime Minister’s department launched data.gov.my, and more recently Big Data Analytics has been identified as a priority area in the 11th iteration of the Malaysia Plan.
Outside of government, there are voices championing open data in Malaysia. At the forefront for many years has been Sinar Project, an independent volunteer group dedicated to making public data accessible in machine-readable form. Now Sinar is more active than ever with many creative projects in the pipeline that make use of public data, or more fundamental works (such as scrapers) that simply make public data available in machine-readable form. All their work is open source. Beyond Sinar, in a recent survey of Big Data professionals in Malaysia, two out of five respondents said that they either ‘agree’ or ‘strongly agree’ that having access to some government data will create valuable Big Data opportunities for them.
Therefore, it is apparent that there is at least some demand for Open Data in Malaysia, and as evidenced by the creation of data.gov.my the civil service is listening. But there is a long way to go. For instance, although data.gov.my is a decent first effort, the vast majority of datasets are released in non-machine-readable formats, predominantly PDF files.
Beyond the federal government, there has been virtually zero initiative from municipal or state governments (even though two states in Malaysia have freedom of information acts). On the demand side although Malaysia has a sizeable IT workforce and an active civil society, it is novel to find the two groups working together beyond the Sinar Project, who have to cope with tight resource limits, as does any organisation run part-time by volunteers.
The Global Open Data Index is important because it provides visibility about where we are and where we can go. Malaysia's entry in the Index is still relatively thin, but once a critical mass is achieved, the Index will be a boon to Malaysia in a number of ways:
1) It would be possible to gauge Malaysia's progress relative to her regional peers, such as Indonesia, Singapore, and the Philippines. Such comparisons can be especially helpful when it comes to winning the support of decision makers in government. 2) Efforts to improve the availability and quality of Open Data in Malaysia can be measured against the Index. This is valuable given the KPI obsession of Malaysia's civil service. 3) It would clearly highlight areas with the most need for improvement, so that additional resources can be targeted appropriately, whether by the data custodians themselves, or by hacktivists building scrapers.
Most of all, the Index would help shine a light on an important civic issue in a society with a strong appreciation for technology, but that is unfortunately often lagging in issues such as openness and transparency. Hopefully, efforts to improve Malaysia's standing in the Global Open Data Index will have spillover effects into the general governance of the country, and the civic-mindedness of every Malaysian hacker.


Administrative Support
This section provides a collection of resources related to many non-technical issues that CS Education researchers and systems builders have to deal with.
Data Access Policies
Researchers are often in need of student-generated data. This might include data generated in the researchers' own courses, in other courses at their university, and in courses at other universities. This might include score data from course assignments, grades for the course, or tracking data of some sort related to student activity within educational software.
While some aspects of data acess and sharing are regulated by IRB protocols, in some instances universities have global policies regarding the regulation of access to such data. This section tries to provide some examples of related policy documents and data access forms.
- University of Toronto
- Website and Informational slide deck describing the University of Toronto data access review policy
- Data access request form
Hosting Information
Help for tool developers who want to make their tools available outside their University, but who need options on how to host the software.
Examples of IRB Protocols
Readers should be aware that each university will typically have its own form and process for IRB approval. While the examples here should be helpful for writing similar documents, you will need to get the exact forms necessary from the school that will grant the approval.
Also, be aware that IRB standards change over time, and can be different at different schools. Dates are shown for these documents. Permissions granted by a university as shown in older documents might possibly not be granted by that same institution today.
- CMU IRB Protocol from PI Carl Haynes-Magyar, last updated early 2023.
- CMU IRB Protocol, Consent Form, and Recruitment Document from PI Tongshuang Wu, last updated early 2023.
HECVAT Examples
The Higher Education Community Vendor Assessment Toolkit (HECVAT) is developed and maintained by Educause. It is intended to create a common, comprehensive tool for evaluating a variety of aspects important for instituations when evaluating third-party software tools. Many universities are now requiring developers to provide a HECVAT form in order to be considered for adoption.
There are several flavors of the HECVAT. From the doc:
- Triage: Used to initiate risk/security assessment requests - review to determine assessment requirements
- Full: Robust questionnaire used to assess the most critical data sharing engagements
- Lite: A lightweight questionnaire used to expedite process
- On-Premise: Unique questionnaire used to evaluate on-premise appliances and software
Complete HECVATs for a number tool are available. If you have completed a HECVAT for your software tool, please consider contributing it to SPLICE as an example for others.
VPAT/ACR Examples
The Voluntary Product Accessibility Template (VPAT®) is a standard document developed by the Information Technology Industry Council for software developers to create an Accessibility Conformance Report (ACR) to explain how their tools meet national and international standards for accessibility. Many state and national governments require a completed Accessibility Conformance Report as part of the evaluation for adopting third-party tools.
Many vendors make the their VPAT/ACR publically available (for example: Canvas | Moodle | Github's Website | MediaWiki | Chrome for Windows). If you have completed a VPAT for your software tool, please consider contributing it as an example for others.
Project Scale-up and Lifecycle Examples
This section contains a "system stories". Most CS educational software never gets beyond the proof-of-concept phase. Sometimes CS educational software gets prototyped and deployed for a couple years in the developer's own classes. A small number of software projects get "institutionalized" for long-term adoption locally, and/or distributed and used more widely, and for a long time.
Getting a project adopted widely, and put on a long-term sustainable basis is difficult. This section is meant to give presentations about CS Educational software that has (more or less) successfully scaled up. The goal of presenting "system stories" is to give developers in earlier stages of the software system lifecycle some ideas of how other groups have successfully or unsuccessfully navigated scaleing up and reaching long-term stabilty.
- OpenDSA eTextbook System (Virginia Tech)


Members
(static) currentTask :Object
currentTask is the currently selected task from the taskList object
Type:
- Object
- Source:
Methods
(static) archiveClick()
archiveClick() is the event handler for Archive button click events. This
method changes the state of the currently selected task to "archived." This
means that the task disappears from the Create / Update screen's task table and is
moved into the Archive screen's task table.
- Source:
(static) completionChange()
completionChange() is the event handler for changes in the
completion slider values. If a task has been selected from
the task list table, then the currently selected task will
have its completion value changed and the priorities of the
tasks in the task list will be recalculated. If there
is no currently selected task, then completion cannot be changed.
- Source:
(static) deleteClick()
deleteClick() is the event handler for Delete button click events. This
method deletes the currently selected task from the task table.
- Source:
(static) effortChange()
effortChange() is the event handler for changes in the
effort slider values. If a task has been selected from
the task list table, then the currently selected task will
have its effort value changed and the priorities of the
tasks in the task list will be recalculated. If there
is no currently selected task, then effort cannot be changed.
- Source:
(static) importanceChange()
importanceChange() is the event handler for changes in the
importance slider values. If a task has been selected from
the task list table, then the currently selected task will
have its importance value changed and the priorities of the
tasks in the task list will be recalculated. If there is
no currently selected task, then importance cannot be changed.
- Source:
(static) initScreen()
initScreen() is the initializer for the create / update screen
- Source:
(static) newClick()
newClick() is the event handler for New button click events. If the
name input field is empty, then a modal will be presented saying that
new tasks much have a name. If there is already a task with the name
present in the name input field, then a modal will be presented saying
that task names must be unique. If the task name is present and there
is no existing task with the chosen task name, then a new task will be
added to the task table, and the new task will become the selected task
in the task table.
- Source:
(static) urgencyChange()
urgencyChange() is the event handler for changes in the
urgency slider values. If a task has been selected from
the task list table, then the currently selected task will
have its urgency value changed and the priorities of the
tasks in the task list will be recalculated. If there is
no currently selected task, then urgency cannot be changed.
- Source:


{% extends 'base.html' %} {% load staticfiles %} {% block content %} {% if registration_status != 'OPEN' %}
| Time | Class Name |
|---|---|
| {{ timeblocks.0.start_time|date:"h:i A" }} - {{ timeblocks.0.end_time|date:"h:i A" }} |
|
| {{ timeblocks.1.start_time|date:"h:i A" }} - {{ timeblocks.1.end_time|date:"h:i A" }} |
|
| {{ timeblocks.2.start_time|date:"h:i A" }} - {{ timeblocks.2.end_time|date:"h:i A" }} |
|
| {{ timeblocks.3.start_time|date:"h:i A" }} - {{ timeblocks.3.end_time|date:"h:i A" }} |
|


For the last three years, I've been working for a company called Workiva. I've worked as a Software Engineer in Release Management, developing tools that make the process of getting new code in production faster and more reliable (and automated 🎉).I've worked on a small team (4 developers), which has given me great experience in many areas of application development (UI, server, API's).
In my time at Workiva, I've worked on many projects. Because I've worked part-time during the school year and full-time over the summer, I've been able to work on and develop many different components of our application.
I've learned a lot from my internship at Workiva. On the technical side, I've learned a lot about database management, API development, UI design and development, object-oriented design, and ground-up application development. On the non-technical side, I've learned how to communicate effectively with members of my team. I've learned that one of the most important things to have among a team is conversation that's not related to what you're developing. I've noticed that team momentum significantly increases when each team member feels valued, and that they are known and cared about outside of the office. I've learned how to communicate with other teams and stakeholders as well.
In regards to what my co-workers think about me, this is the most recent review I've been a part of:
How do their strengths or abilities contribute to the success of the team?
- Joe is the best code reviewer on the team
- He loves to look for the most optimal solution for a problem
- He produces good code quickly.
- Attention to detail during code review
- Raw programming talent
- Dedicated to doing things the right way
- Probably the strongest developer on our team when it comes to straight code quality/efficiency
- Able to churn through a lot of tickets quickly and successfully
- He is always watching for efficiency and consistency
- He thinks through the edge cases well, and has prevented more than a couple of bugs from slipping into master by spotting a missing Nonetype check during review.
- His contributions to recent error handling/exception changes have made code more consistent and readable.
What positive impacts do they provide to the team/company?
- During code reviews, Joe forces the rest of us to think hard about why we made certain decisions while writing code. This leads to a better overall quality of code.
- When Joe isn't in school, the amount of bugs we have is noticeably reduced because he reviews more.
- The individual pull page has made it far easier to support rosie, and in turn, has improved our ability to get releases out the door quickly.
- His MARV rewrites have significantly improved the usability of those popular pages, and in turn reduce the amount of time that developers on other teams have to spend preparing their releases.
- He has made hundreds of improvements to existing functionality, and his work writing unit tests/code reviewing prs have both steadily improved the quality of the rmconsole code.
- Joe is always a great resource for a code review, and has been very beneficial and vocal in code design brainstorms as well.
Do you see this person as a leader within the team?
- I think everyone on the team is a leader in their own way, and Joe is no exception. He is always willing to look at something with me and loves to discuss the best way to implement things. Just like the other members of the team, I look to Joe for advice often.
- I think that we all strive to follow the examples he has set in what a good code review looks like and how a solid engineer should act.
Does this person positively contribute to your success?
- He makes me think harder about why I made certain design decisions. This is important because when I have to justify my decisions, it forces me to look at the benefits and consequences of my design. This makes me a better programmer.
- His easy going nature is a great influence upon the team
- I always feel more comfortable merging a pull request that I know has his +1.
Additional Comments
- The production on the team goes up during the summer because Joe is here
- He is a valued member of the team.
- I am constantly impressed by Joe as an Engineer and as an Individual.
- Our velocity increases substantially when he is around, and I hope that we are able to keep him around after graduation.


|
|
JQuery Samples |
Zazl is a Dynamic Javascript Optimizer that enables the loading of AMD modules and all their dependencies in a single response stream without depending on static build tools. It also leverages JavaScript compression tools such as Google Closure, Uglify-js and Dojo Shrinksafe.
The samples use the Zazl AMD loader to load their modules.The Zazl backend component that performs all the dependency analysis and optimization is running on a Node.js based server.
The Text Messenger sample demonstrates the Zazl Optimizer loading a JQuery/JQuery mobile/Backbone/Underscore application. Take a look at the javascript network traffic in a browsers developers tools to see the optimization in action.
The samples source code can be found here


New release of v0.4.22
Binaries for MultiBit version 0.4.22 are now available.
Features
- Addition of OpenExchangeRates.org as an exchange. Provides over 150 currencies for currency conversion. (Needs free sign up)
- Charts can be saved (right click on the chart: "Save as")
- Reset blockchain and transactions default "replay from" date now goes back 2 days.
- Updated to Bitcoinj 0.7.1, XChart 2.0.0, XChange 1.5.0
- Simplified buttons in wallet list
Bug fixes
- Fixed appearance of blank request screen.
- Menu tooltips on Macs shown properly
Release info
11 March 2013


Pour a Little (Lucene) Sugar in Your Scala
Please say hello to Lucene Sugar: a library that provides a more concise syntax for the Lucene API in the Scala language. Lucene Sugar makes it easier to:
- compose Lucene indexes using the familiar Scala cake pattern
- add indexed and/or stored fields to a Lucene document
- index collections of documents
- search! (You didn’t really expect that, did you?)
My general goal for Lucene Sugar is to turn some standard operations on their head. For example, instead of:
scala val doc = new Document doc.add(new StringField("string_field", "aString", Store.YES)) doc.add(new LongField("long_field", 123456L, Store.NO)) doc.add(new StoredField("int_field", 10))
you can now write:
scala val doc = new Document doc.addIndexedStoredField("string_field", "aString") doc.addIndexedOnlyField("long_field", 123456L) doc.addStoredOnlyField("int_field", 10)
Lucene Sugar is still in its infancy, but I believe it already offers great value to anyone wishing to use Lucene in Scala code.
Why I Created Sugar
Gilt’s inventory includes millions of different items in limited quantities. These items are sold quickly, which means that our inventory is constantly changing. A few weeks ago I found that I needed a data store capable of:
- storing items composed of text and numbers
- being indexed and filtered using extremely specific criteria (for example, all white shirts from Paul Smith that can be shipped to Canada)
- working quickly and efficiently (a few 100ms per query)
- being embeddable (I wanted the data management to be self-contained in the service without requiring any external dependencies
I’d used Lucene for other projects, and thought it might be a great fit for what I needed. In fact, it turned out that–despite its wordy API–Lucene works very well. To overcome the excess verbiage issue, I added some “Scala syntactic sugar” around the Lucene API to make it more concise and pleasant to use. After doing some coding, I realized that it could be helpful to convert this higher-level API into a library that could be reused in other projects. (I also badly wanted to publish my first open source Scala project, so this was a very good candidate.)
With Lucene Sugar, we can now build a search and browser service on top of our inventory data; the data is composed of textual attributes such as product name, brand, color and description as well as numeric data like price and size. I hope you find it useful as well!
Photo by Uwe Hermann. Creative Commons license.