Build Room Reservation System using Sierra REST API
2016 SCIUG Conference at Loyola Marymount University (Oct. 14)
Created by Seong Heon Lee, Systems & Technology Librarian
Hugh & Hazel Darling Law Library, Chapman University
Welcome everyone. Hi, My name is SeongHeon. I am Systems & Technology Librarian at Chapman University Law Library. First of all, thank you for being my audience. Today, I want to share about our summer project. We built a room reservation system using Sierra REST API. I hope that this session can be meaningful for you in some ways.
Final Product
During the last summer, Law Library implemented a room reservation system. It tooks about 6-7 months including planning and preparations before summer. I will talk about the details of the whole project later in this session. We could finish the project before the start of this Fall semester. This screenshot shows our final outcome. The new room reservation system is currently running on a production server and serving law students everyday.
Why Did We Start?
An Email from David, Circulation Librarian
"We notice a strange problem with the Law School’s Study Room Reservation module. Apparently if you make a 1 session at 8am it will reserve the room for the entire day. At any other time of the day you can make a 1 hour session with no problem. When you get a chance would you look into this?"
Let me start with this question: Why did we start this project? One day (6/19/2015), I got an email from David, our circulation librarian. He notified me a strange problem that RRS reserves the entire day although selecting the first hour (8:00-9:00) only.
Our old system was a custom-made which IT developed specially for Law Library. There are Pros and Cons of using a custom-made system. One advantage is that we can locally customize the features and design as we wish. However, this advantage can become a drawback, because we are responsible for anything that is broken.
So, I emailed to Anthony in IT who was in charge. However, I received an automatic absense email from him. I could not reach him for next two days.
Reply to David
"Thanks David for the notification. Anthony seems out of office till 6/21. Will Keep you posted."
So, I replied to David. What a great email that I could send as a Systems & Technolgoy Librarian! I got a little frustrated, because I had never seen the system code and we could not access the person who should fix it for the next two days.
... A Week After (6/25/2015)
David:
Okay it looks like the problem has been fixed. Also, it looks like Bill was the one who resolved it instead of Anthony.
Me:
Great! Thanks for informing this.
A week later, David emailed me that the problem has been solved, but by Bill not by Anthony. Although I was so puzzled about what was going on behind the scene, I felt OK when I heard that the problem was fixed.
[CLICK] So, I sent a thank note.
... Two Weeks Later (7/10/2015)
David:
It looks like there is another problem. I don’t know if this is related to the problem we had before. It seems if you make a reservation that ends at 10pm, it will not show the reservation for the last hour.
David emailed to IT to check the problem.
Two weeks later, David emailed me again that there was another problem. For some reasons, the last 'reserved' hour display as not-reserved. How is this possible? What's going on?
[Click] And David emailed to IT to check the problem.
... A Week Later (7/16/2015)
Me:
Did IT fix this problem?
A week later, I emailed to David to ask if IT took care of the problem. The answer was not yet.
... Another Week Later (7/23/2015)
David:
Anthony, do you know the status of this case?
Another week later, David emailed to IT to get status update.
... Another Two Weeks Later (8/7/2015)
Me:
Did IT fix the problem?
David:
Not yet. Anthony said that he would get back to me past Monday, but I didn’t hear from him.
Another two weeks later, I asked David about the status. [Click] And he told that the problem had not been resolved yet. We were getting tired, losing patience.
... A semester started, while the system was still broken
[Read] Our law school semester starts 2 or 3 weeks earlier than our main campus. So, we can be badly affected if we are caught up in a wrong maintanence cycle. This was exactly the case. The last reserved hour still shows "not-reserved".
... About a month later (Sep. 21)
About a month later, we see this screen. [Click] The prevous problem was kind bearable. But, this was not. Users cannot access to the system as such. I contacted IT to find the cause of the problem.
Email from IT
Would you write STEP-BY-STEP procedure of making a reservation?
This is the email reply that I received from IT. [Read] What? Really? My frustration level was growing. You can understand me if you had the same experience: how hard is it to write descriptively with details when you get completely emotional.
Calm down! Breathe! I sent a STEP-By-STEP process with sceenshots. Finally, we found that this error happened when IT changed our ID Management System from Datatel to PeopleSoft. Our Room Reservation System was using Datatel system to check user credentials.
Summary of the Story
Manage Library Technology
Internally
vs.
Outsourcing
Why do I share this story? It is not my intention to talk about the inefficiency of IT support. Chapman IT Department had big overhaul last year, migrating Campus Resoruce System, re-structuring staffing, etc. They are reasoanble excuses. [Click] The reason that I bring this story is to question about system management process: Are you going to manage library technology INTERNALLY or with OUTSOURCING?
I don't thnik that there is ONE answer for this question, because our contexts are all varied, such as university policy, staff skills and size, communication channel, project delegation process, etc.
But certainly, our last summer exprience convinced me that we needed a reasonable control on our own services. In this way, we are not affected helplessly by outside factors which we cannot handle. As you heard from the story, it was really difficult for library staff to know the behind scene: we could not see the codebase of the system; we could not know who were on duty for our service ticket; we could not see why and when our system got affected.
So, we questioned:
Do we need a new system?
How Did We Start?
First, disucss available options.
Three options:
Fix it
Leatherby's
Other Alternatives
How did we start? We were natually in the position to start discussing about the future of our RRS. We spent the whole semester of Fall 2015 for that discussion. There were three options that we can consider to pursue.
The First option was to fix it. However, we excluded this option, when we found that the broken template issue (first and last hours were not display correctly) was related to a third-party calendar view component. The programmer explained that he coult not make it work because of unknown changes of the templates. I could not see the whole pictures. However, I could certainly get a sense that there were some degeneration of the application. The promgrammer could not only resolve the error but also he did not have time to fix the problem. Our study room reservation systems was not high priority, particuarlly in that summer when lots of new changes happened in IT. In result, library staff agreed to move onto another system.
The second natural option was to share Leatherby's (our main library's). Before our Room Reservation System had troubles, there were several occasions that we updated small parts and features. Because the main libary had its own room booking system and a circulation librarian encouraged us to join their system, we thought that it could be a good option. This could be good with two reasons: first, we don't need to ask IT to maintain our system. Second, IT does not need to support two different systems. That's definitely good news for IT. So. Law Librarians met Leatherby's staff to check if the system would be sufficient to support all our needs. We were mostly convinced with the features. Although we had to tweak a little bit here and there, overall, it looked reasoable for both of us.
However, our Library Director wants to find more options before our final decision. Even though our old system had many troubles, there was one thing that we really liked about: that was - the fact that we could locally customize as we like. This is a kind important if we want to customize a system user-friendly. For example, using Leatherby's, our law student should step through a few clicks before landing on actual reservation page. And we also concerned about possible cases that we may need to run different policies/rules. Sharing the same system means that we need to compromise in such conflicting cases. So, we decided to search for other alternatives that we can freely run our policy, operations, design, etc.
LibCal as a Candidate
In Feb. 2016, our library director was informed from law library director listserve that LibCal is a good product. And she wanted me to check it.
Testing LibCal
Intuitive and flexible Admin Pages and Features
Bundled with other sister products, such as calendar, appointment
Booking widgets embeddable on other websites
Limit access by domains (e.g. @mail.chapman.edu)
User authentication module, LibAuth
Reliable Supports: users and software
I signed up Libcal trial to test its functions. I was personally impressed by clean design and powerful featuers. LibCal was a good candidate for our library. Most importantly, LibCal would provide the chance of customizing our design and policies. These are some highlights of LibCal. [Read]
However, there was one critial problem remained. We should implement an User Authorization.
User Authorization
Open login (default): name and email
Restricting by domain: @mail.chapman.edu
Third-Party Integration: Shibboleth, LDAP, SAML, CAS, SIP2, and a remote self-hosted script option
Because Law Library allows only law students to sign in the Room Reservation System, we must have a login procedure to authenticate law students only. So, I check the login options of LibCal with testing it and reading the product website. I learned that there are three options. LibCal,by default, is open to all users as long as they have a name and an email. Secondly, LibCal can limit access by email domains like @mail.chcapman.edu. However, this option would still allow all Chapman students to access to the system. And finally, other third party options like LDAP are available. However, we could not integrate LDAP with LibCal, because Chpaman LDAP did not recognize "LAW" students. It was kind a bummer, because all other features had already passed my criteria. User Authorization problem appeared as a deal breaker.
[Click] Howevever, I was curious about the statement "a remote self-hosted script option". I emailed to SpringShare to check what they mean by the phrase.
Remote Self-Hosted Script
"The self-hosted option is for if you have a custom configuration that's not covered by the other options. What we do is POST the username and password to a remote URL you host. We recommend that the authentication returns json formatted like..."
{
"firstname":"James",
"lastname":"Bond",
<EMAIL_ADDRESS>"auth":true
}
SpringShare emailed me back with an explanation. [Read] Translating this English email, they simply meant an Web App which can receive a POST request from LibCal and return a user record.
When I read this reply, Sierra REST API immediately came accros to my mind. This kind of WebApp is exactly what Sierra REST APIs were designed for.
Sierra REST APIs
Sierra REST APIs has Patron Find API. Provided with a barcode number, the Patron Find API will return a patron record with name, email, and more.
A simple diagram of architecture is like this. When a user sign in a study room on LibCal site, the LibCal has to authorize the user first. So, LibCal passes a user request to Sierra REST API. Then, Sierra REST API finds a patron record and return it back to LibCal. Once all authorization steps are settled, LibCal serves the user.
Web App
However, we need one more application layer for this system desgin to work. Because Sierra REST API does not return patron data in the format that LibCal required, we need a Web App that can handle the middle process between LibCal and Sierra REST APIs.
What does the Web App do?
Receive an user request from LibCal
Pass the user request to Sierra REST API
Receive user data from Sierra REST API
Process user data in the format that LibCal requires
Return user data to LibCal
Let's dissect more closely the functions of the Web App itself. [Read] Those five steps are implemented in this code.
Code View of Each Step
First, setup an URL path (isPatron) in the WebApp to which LibCal will send a Post request. LibCal also send both username(email) and password(barcode). The WebApp converts both inputs into variables for the next steps.
Second, the WebApp passes the barcode to Sierra REST API to request a patron record. At the same time, the Web App requests a query selecting only a few fields (names, emails, barcodes, patronType).
Third, Sierra REST API will find a user record and send it back to the WebApp. The WebApp will receive the data in the response 'body'.
Fourth, after receiving a user record, the WebApp will confirm if the patron is 14 (law student) and username(email) is matching. If a user is valid, the response data will be processed into the json format as in yellow box (firstname, lastname, email, auth in JSON format).
Fifth, finally, the WebApp will send the processed data back to LibCal.
Behind the Project
A Short Code with Patron Find API
No access to Patron Find API till the 28th of July 2016
Patron Find API available with Sierra 2.2
Sierra's full OS upgrade
Developer Sandbox
Local Custom Patron API
Now let me step back a little bit to share the behind stories of the project.
First, the short code shown in the previous screen (around 40 lines) covers all the core functionalities of the WebApp that integrates Sierra REST API with LibCal. There are some extra codes like getting an Access Token. However, that is pretty much all of it.
[Click] However, I could not write this code in the beginning of our project, because we didn't have access to the Patron/Find API till the 28th of July 2016.
[Click] Patron/Find API is shipped with Sierra 2.2. Chapman University had Sierra 2.1 at the moment of preparing our project. Eventually, we had a plan for Sierra upgrade (2.1 to 2.2) in early June (before summer). I thought to build the code after that upgrade.
[Click] However, an unexpected thing hanppened, as always. This time, the Sierra upgrade required a full Linux OS upgrade as a prerequisite. Because we could not guarantee how soon Innovative could upgrade OS on our Server, our Sierra upgrade schedule seemed falling into a black hole.
Remember that we launched the real product WebApp two weeks after (August 10) we could access to Patron Find API. How could I work around the schedule conflict? [Click] This is how I did. After realizing that our Sierra upgrade will be delayed, I decided to prototype the WebAPP interacting with Developer Sandbox, which was including Patron/Find API at that time. Usually, Developer Sandbox runs the latest version so that it is a great place to expriment new APIs recently released. The Developer Sandbox is specially helpful if your Sierra is an old version.
[Click] Meantime, I encounterd one important question. What would happen if we could not upgrade to Sierra 2.2 before our semester starts? Although the prototyped WebWep can work with the Developer Sandbox, it would not do so with our Sierra Server. It looked like kind of gamble that we were helplessly waiting for an unknown OS upgrade schedule. So, I decided to build up a Local Custom Patron API.
A Custom Patron API
This is the diagram of Local Custom Patron API. First of all, the WebApp extracts patron records from Sierra PostgreSQL. And then, the WebApp stores them locally in the web application server. In this design, when LibCal requests a patron data, the WebApp sends a patron record directly from its own server, without delegating the request to Sierra.
Extract data (law students) from Sierra PostgreSQL
Let's break down a little bit in details. First, it extracts law student records from Sierra Databases. Sierra Database is approchable through Sierra Direct SQL Access. I use KNEX library when communicating with our local PostgreSQL database. KNEX is a JavaScript library of SQL query builder, which works with major databases such as PostgreSQL, MySQL, MSSQL, SQLite.
Second, it stores patron data into a json file inside the web applcation. The json file will work exactly like a data storage.
Send data to LibCal
Next, this is a breakdown of the interaction between LibCal and the WebApp. After receiving a patron request, the WebApp reads the JSON file to find a patron. Then, after formatting the patron record as LibCal requires, the WebApp sends it back to LibCal. The code in this screen and in the previous one provides all functionalities for the Local Custom Patron API.
Accidental Invention
Custom Patron API AS Offline Service
On the 28th of July, two weeks before this semester started, we could eventually upgrade to Sierra 2.3. I could finally access to Patron Find API. In spite of tight schedule, I could quickly complete the WebApp because of the the prototype that I had already built using the Developer Sandbox. In the meantime,the Local Custom Patron API I built had no use anymore, although I had a good idea on how we are using it. Imagine what will happen when Sierra Server fails. This is not something that would frequently happen. But it is still possible. Because Sierra REST APIs are running on Sierra Application Server, the WebApp will not authenticate patrons if Sierra Server does not work.
[Click] What about using the Local Custom Patron API in Offline? (Pause!!)
Offline Service
What do I mean by "Offline Service"? Let's see the diagram again. Even though the WebApp does not access to Sierra REST API or Sierra Database, the WebApp can still serve without problem. Because it contains patron records inside, it can respond to LibCal with a patron record. Without a connection to Sierra API, the Local Custom Patron API can still perform its duty. So, I decide to use it when Sierra Server is down. It is an accidental invention. It's kind cool.
Go Live!
The WebApp is completed. What is the next step? We have to run it on a production server. Technology stacks that I chose for the WebApp are Node.Js and Express.Js. Node.Js is a server-side JavaScript environment, on which we can run a web application. Express.Js is a Web Application Development Framework for Node.JS. I developed the WebApp using Express.JS. Node.JS can work as a standalone webserver. However, it is usually integrated with traditional web server in production (e.g. Apache, Nginx, IIS-Windows Web Server), because it can serve static pages better and does not need a separate process manager like PM2. I used a third-party module, "IISNODE" which will link a node.js application to IIS web server. Before this summer, I prepared a window server with IT Department and configured both IIS web server and IISNODE module, so that we could deploy our production app as soon as it was ready.
Development vs Production
4 Second Timeout Issue
Don't expect that your code in the development environment works in the same way that it works in the production server.
Unknown rules: 4 second timeout
IIS Process Recycling
their party apps: Virus-Scanning
Automatic request script
When we deployed our application for production, it looked working well. I tested user login serveral times every day manually with a dummy student account. However, I discovered soon one strange problem. Every first-time login in the morning failed. And then everything works fine for the rest of day. I started chasing the cause of the problem. I discovered that the error was related to a "timeout"" issue. I was curious why and where this timeout occured. Speaking with SpringShare development team, I learned that LibCal disconnected automatically its request if our WebApp did not respond in 4 seconds. This is a security feature of LibCal/LibAuth. After the disconnection, the WebApp had no way to communicate anymore with LibCal regarding that request. This means that each request must be answered within 4 seconds without any delay.
However, it was weird because the timeout only happened one time in the morning. Searching various possiblities, I found that the issue was IIS web server. The web server recyled once a day the process on which the WebApp was running. In addition, overnight scheduled virus-scanning also made the process recycled. After the process recycled, the process took some warming-up time when restarting. When the first request came in after the process recyle, the warming-up time took more than 4 seconds. That's why the first-time login failed.
[Click] The lesson that I learned: Do not expect that the code in the development environment works in the same way that it works in the production. [Read]. [Click] My solution for this issue was to create an automatic request script.
I wrote a short PowerShell script that sends a dummy request every hour. The script has two purposes: first, warming up the server after the process recyle and second, monitoring if the server is still running on.
Monitoring the App on Server
Who access?
Requestor IP
Response Time
Simple View for Quick Review
Last but not least, we need a monitoring system to check the actitivies of the Web App on the server. I was particularly interested in who's accessing, requestor IPs, and resonse time. Of course, it must be easy to review quickly.
IIS Web Server Logs
IIS log files include many information (15 fields); Obviously, I did not need all. And it is also hard to read because of different length of each line, not pretty indented and aligned. So, I wrote a small python script which extracts only necessary fields from the original log files.
Code of Log Analyzer
First, it extracts only 9 fields. Seond, it color-codes the requests from LibCal to distinguish them from other requests. All LibCal requests will be stylized in blue font, except any request caught in 4 second timeout rule. They will appear in red font. Third, it marks other requests bold if they are caught in 4 second timeout. This will catch the request coming from PowerShell which warms up the web server after the process recycle.
Log Looks Like
The simplified log file looks like this. As you see, readability gets improved. We can quickly scan all requests, because each request is aligned in pretty format. The requests in Blue-color are all from LibCal. Blue means that they pass 4 second timeout rule. Good part is that I don't need to read the response time of each request (which is in red box) line by line. And bold means that it failed 4 second timeout rule. We see one request at 11:00 (UTC, 4:00 PT). This request comes from PowerShell Script right after the process recycle every early morning. Because this request will warm up the WebApp's process and make it ready to serve next logins, the users will not exprience any failure of login.
One more thing I have to mention is that the python cript auto-runs in background once a day. So, I do not need to run it myself, unless I really need to check the latest requests.
REST API
Re presentational S tate T ransfer
Web Architectural Style with 6 contraints: client-server, stateless, cashable, uniform interface, layered system, and code on demand
Separation of Concerns (client vs server)
Stateless (No meddling each other)
HTTP Protocol (Get, Post, Put, Delete)
So far, I have talked about why and how we built a Room Reservation System. Before closing this session, let me briefly touch upon REST API. With purpose, I arrange this part at the end of my talk. Because we have already seen some real examples, it will be much easier to grasp its concept. What is REST API? Why is it so a buzzword today?
REST stands for "Respresentational State Transfer". That's a big phrase. The word was first coined by Roy Fieding in his doctoral dissertation Chapter 5 (UCI). [Click] He defined REST as a Web Architectural Style which is characterized with six contraints, such as client-server, stateless, cashable, uniform interface, layered system, and code on demand. Lots of words.
[Click] Let me hightligh three key concepts. First, the fundemental key concept is separating the concerns of client from the concerns of server. Client conerns user interface, while servers concerns about data resource. Separating their own concerns will make web achitecture more scalable because each components (client and server) can evolve independently. [Click] Because of this separation, Client and Server do not meddle with each other. They do not impose their own condition(state) onto the other. [Click] Thirdly, REST uses HTTP protocol and its verbs (GET, POST, PUT, DELTE), which are already familar to web community. This makes REST implementation simple and familiar. Let's look at a picture to help our understanding.
Representation & Resource
As you see, Client and Server interact with each other. Notice that they have their own concerns (User Interface vs Data Resource). The Client sends a request to the Patron Find API Endpoint with parameters. An endpoint is the place that the Server promises to serve a certain type of resource, in this case, Patron Find Resource. And parameters present which resource the Client wants to get. Here, parameters are specified by a bacode and selected fields. Both Endpoint URL and parameters make a URI (Resource Identifier). Then, the Server receives the URI request and respond "a resource". We call this 'A resource' a representation of resource or STATE. Notice that this representation is purely created by the Client's decision (with parameters). The Server itself has nothing to do with the "state". The Server just serve all possible resources at Patron Find Endpoint; the Client consumes a specific patron record at the endpoint using parameters.
REST and Buffet
food (resources) are served at the bars (endpoints)
This is an easy analogy. You are familiar with how buffet restaurant works. Chelfs prepare sets of foods and display them at the bars. And the customers choose the food at the bars which they like to eat. Chelfs do not take direct orders from consumers, although Chelfs select the dishes based on their study of customers' tastes. And the customers cannot complaint about why Chelfs cook in a certain styles and why some foods are not provided. Here, we can find clear sepration between the Chelfs and the customers. This will improve the efficiency of preparing foods. Although the customers cannot make an order directly, they have pretty good enough choices at the bars. They can choose the foods with their current state of mind. Interestingly enough, Chelfs do not decide the state of customer taste. That decision is all up to customers. [Click] Chelfs and customers never talk each other directly. However, food (resource) are served at the bars (endpoints).
Sierra Developer Sandbox
Let's take a look at a real Sierra REST API. This is Sierra Developer Sandbox.
I will demo Patron Find API. First, we need to select the right endpoint. And then we create parameters (barcode =<PHONE_NUMBER>2715747, fields = emails,names,patronType).
When we request a resource, the Server returns a body which is the representation of resource (state).
Other REST APIs
There are many REST APIs out there.
Facebook API (Graph): Graph Explorer (/sciug/posts). It pulls all SCIUG posts.
Google Map Place API: with longiture,latitude,rankby,types, it will return useful place data (food place around Loyala Marymount University campus).
Why REST APIS:
Access to Existing Data
(e.g. Sierra Patron Records)
Finally, let me finish this session with sharing my thought on why REST is so popular today. The first thing is accessiblity to existing data. Data is so valuable today and will be more so in the future. Digital data is accumulating with the greatest speed in human history. We saw that those zillion valuable data is available "for free" through many REST API services, like the ones from Google, Facebook, and Twitter. It reminds me of the 19th century Gold Rush, when many poeple believed in California Dream. People endeavored a long journey to serach for golds in hills and rivers. Somebody may try to build data from fresh start. However, if those data is freely available, do we need to build them again?
Why REST APIS:
Reuse the data in different apps
(e.g. Patron Authorization Web App)
Second, reusing the same data in different apps is smart. The data will be totally transformed in a new context. Data is like seed. It can be replanted in different gardens and can flurish in a new form with unique beauty. Like this vertical garden (Vertical Garden at CaixaForum in Madrid, by Patrick Breen). Reusing ready-available data, we can also quickly build a new app for other purposes.
Why REST APIS:
Integrate different systems
(e.g. LibCal/LibAuth and Sierra)
Third, when data being shared, the systems that share the same data are being more closely integrated. As you know, last year at the annual conference, Innovative introduced "Open Library Stack". After aquiring many products, they planned to consolidate those different products based on APIs. They also open the data to the third party. This will certainly produce an econsystem that Sierra data can be consumed by different product,as our library did with LibCal.


NetBeans NetCat and QC
Insides to community-based testing
Benno Markiewicz
Who am I?
Senior Java developer @
http://www.ecg-leipzig.de/
Certified NetBeans Platform Associate/Engineer/Committer
NetBeans Community Award Winner 2013
Patch and plugin contributor to NetBeans
Participant in NetCat 7.3/7.4
Follow me at
Twitter
Table of content
NetBeans? NetCAT?
Collaboration, Bugtracker and Dashboard
Test specs
Pre-Integration testing & UI tests
Bonus
15 lessons learned
Estimation
Break the rules
What is NetBeans?
Rich Client Platform based on Swing ->
Showcase
IDE for JavaSE, JaveEE, PHP, C++, Groovy...
15th anniversary in 2013
https://netbeans.org/
What is NetCat?
NetBeans
C
ommunity
A
cceptance
T
esting
Why?
http://wiki.netbeans.org/NetCAT
http://wiki.netbeans.org/FaqNetCAT
NetCAT-tribes
One leader per tribe - real world project users
Review and execution of TS
Review of tutorials -
NetBeansTutorialsForCommunityReview
Bugs and exceptions reports get more attention
Gamification (points, shirts, recommendations...)
NetCat Community Leader Jiri Kovalsky
Jiri Kovalsky - Community Leader
Interview at dzone
Collaboration
E-Mail (mirrored in forum)
Wiki
Google Drive (Spreadsheets)
Dashboard
Weekly Status Update by Jirka
Example
Includes statistics about incoming bugs and what's happened in mailing lists
Issue tracking
Bugzilla @
https://netbeans.org/bugzilla/
Used by community and devs
Issue-lifecycle (pretty standard)
http://wiki.netbeans.org/IssueLifeCycle
http://wiki.netbeans.org/wiki/images/6/6e/Bug-life-cycle_IssueLifeCycle.png
Priority P1..P4 guideline
old
|
new
Duplicates raise the priority
Exceptions reporter with similarity detection and statistics
http://statistics.netbeans.org/analytics/
How to handle >7000 bugs/RFEs?
Bug-Dashboard
Dashboard (
all
|
by NetCats
|
by user
)
Test spec
Example
Single test
Test spec review
Spreadsheet
http://blog.idrsolutions.com/2013/09/testing-netbeans-7-4/
Progress page
Mercurial & Pre integration testing & CI
Mercurial -
http://hg.netbeans.org/
Parallel Repo Integration - Pre integration testing
Why?
"Codebase not compilable for 8 weeks." Missed 2500 bugs - #12
How?
project repos:
jet-main/web-main/...
main-silver
(integrates project repos, failure rejects update)
main-golden
(pulled from stable silver + artifacts)
http://wiki.netbeans.org/HgParallelProjectIntegration
http://wiki.netbeans.org/WorkingWithNetBeansSources
Hudson @
http://deadlock.netbeans.org/
Automatic functional testing
UI-tests based on Jelly/Jemmy
http://wiki.netbeans.org/Writing_JellyTools_Tests_Guide
http://wiki.netbeans.org/GUI_Test_Stability_Guidelines
Tests must pass before integration in more stable repo
BONUS
Additional resources
15 Lessons Learned from 15 Years of Quality Control
(!)
#4: Release only if you get bugincome under control p18
#9: Quality of TS
#10: Code Coverage - Use wisely or not at all p36
#12: Pre-integration testing
#14: What to test? p48
#16: Quality before Feature Freeze p56
Estimation and Release-Roadmap
Roadmap
Global feature plan -
example
More detailed plan per component -
example
Quality-driven releases (Quality Gates - See dashboard and Bonus slides)
Break the rules - Intellij IDEA
Data-driven tests
No feature specs
No test specs
"Full-time dogfooding"
"HEAD is a usable IDE every single day"
Crowd based testing -
EAP program
Gamification - win licenses
Info based on
http://de.slideshare.net/intelliyole/from-renamertopolyglotide


{{/* Copyright 2020 Google LLC Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */}} {{ range $j, $operator := $.Site.Data.consolidated_log_list}} {{ range $i, $log := $operator}}


I am a Responsive Designer & Developer who thrives on making sure others are making forward motion in their lives by giving them a home on the Internet. When I'm not glued to my computer, master crafting websites, I like to read, learn, and spend time with family.
I was born in Los Angeles, and my parents both grew up in California. However, my dad was born in Texas and I spent many summers there visiting his family. Texas is a great state, and I would like to go there more often.
 It can be frustrating at times, but it is completely worth it in the end.
Fun fact: living in the South, I find that I should have been here a lot sooner. The people are nice, for the most part, and the food is fantastic! I have also been able to focus my path to where I want to go.


Timer value: {{time}}
It can be used many times:
It subsribed once and async pipe unsubsribes it after component destroy


You have completed this course. Here is what we covered: Briefly discuss mechanisms of hemostasis Coagulation tests and lab monitoring Anticoagulation -Heparin -Direct thrombin inhibitors Click the button below to complete this course. Complete this course


john deere snow blower 37a
1975 John Deere 210 with Model 37A Snowblower Blowing Snow ...
May 29, 2009 . Here's a long and then some shorter clips edited together of trying out the operation of a 1975 John Deere 210 (10HP Kohler engine) with a .
http://www.youtube.com/watch?v=YC555U1oqyY
Snow Blower Parts
Try our Snow Blower Replacement Parts Search Engine Now. . prwb09c [2.21. 10.4] {37} . John Deere snow blower parts, Toro, Honda, Ariens, Atlas snow blower parts, and snow blower parts for Snapper are sold in our snow blower parts .
http://www.partstore.com/Content/CategoryPages/Lawn-And-Garden-Snow-Blowers.aspx
OMGX20482 - Operator's Manual - John Deere
Snow Blower. 42-Inch Serial No. (010001-) . Quality Service · Service Literature · Parts · Replacement Parts · John Deere Quality Continues with Quality Service .
http://manuals.deere.com/cceomview/OMGX20482_J4/Output/Index.html
Things You'll Need
- Certified copies of public records evidence in your case
Instructions
-
-
1
John Deere Snowblower Parts
John Deere snowblower parts and accessories. Easy Online Shopping.
http://jackssmallengines.com/john_deere_snowblower_parts.cfmJohn Deere 214 with 37A snowblower - YouTube
Feb 6, 2010 . 1979 John Deere 214 plowing snow Feb 2010. . John Deere 214 with 37A snowblower. Asymair95·53 videos. Subscribe Subscribed .
http://www.youtube.com/watch?v=8500LB-0TRQ -
2
Did we miss out on 2005-2011 John Deere Snow Blowers?
I want to start out by saying I'm a huge John Deere fan. . My question is I went to buy a snowblower November of 2012 and found out John Deere wasn't . HELL NO I owned and operated a automotive machine shop for 37 .
http://www.abbysguide.com/ope/discussions/65394-0-1.htmlHow to Hook Up a 37A Snowblower to a 110 John Deere | eHow.com
How to Hook Up a 37A Snowblower to a 110 John Deere. John Deere manufactures large snow blower attachments, like the 37-A that attach to the front end of .
http://www.ehow.com/how_11403485_hook-up-37a-snowblower-110-john-deere.html -
-
3
Will a model 42 snow thrower fit a john deere gt262
Will a John Deere snow blower model number g338k fit a John Deere tractor model number 185 . What model tractor will a john deere 37a snowthrower fit on ?
http://wiki.answers.com/Q/Will_a_model_42_snow_thrower_fit_a_john_deere_gt262 -
4
1975 John Deere 210 Lawn Tractor with Model 37A Snowblower ...
May 24, 2009 . Restored 1975 John Deere Model 210 Lawn Tractor with Model 37A Snowblower. 10 HP Kohler engine. Wheel weights and chains obviously .
http://www.youtube.com/watch?v=bhYCaFIJT30Snow Blower For Sale at TractorHouse.com
Snow Blower, 848A; S/N: 4288933; Stk #: 157080; Used; Fits To: JOHN DEERE / 4630, 8100, 8200, 8300, 4240...;Auction: 3/4/2013 - 3/20/2013;. Online Auction .
http://www.tractorhouse.com/listings/components/acsearch.aspx?catid=22037
-
1
References
Resources
- Photo Credit Justice image by MVit from tortiere french canadian meat pie recipe


ethylene senescence flower petal Plant flowers expression genes carnation Arabidopsis gene petunia longevity Biol. transgenic van {border-style plants Sci. px;} #ffffff;} Ichimura, Shibuya receptor ACC NAC Physiol. plant cut Bot. Ethylene synthase biosynthesis morning petals response senescence. species abscission ethylene-independent molecular production senescence, Cell Exp. Mol. Wang, ethylene-dependent glory EIN EPH Japanese Postharvest Shibuya, TFs ornamental oxidase regulation reported responses signaling -aminocyclopropane--carboxylate Doorn Hort. Hortic. Reid, Soc. Table Woltering analysis example, improve involved life reduced regulated senescing sensitivity transcription ACS Chang, Technol. exogenous gene, including px; role rose {font-family ACO Chen, Clark, D.G. Ecker, Genes H.J. J.R. Liu, M.S. Molecular W.R. death floral flowers. font-size pathway plants. promoter protein regulates Delphinium Dianthus Doorn, Huang, Japan. L.) PhFBH Res. W.G. Woodson, Yang, caryophyllus cell days double; encoding endogenous etr- factor hybrida inhibition isolated little orchid peony receptors species. tree Biotechnol. Campanula Cloning E.M. Flower Meyerowitz, Role Satoh, Science Wang Yoshioka, Zhang, associated biosynthetic border-color border-width breeding characterization control delay does effects ethylene, ethylene-insensitive family genome geranium important mutated negatively regulate regulator solid; species, specific studies suppression vase {font-style {font-weight (ETHYLENE A.B. Biochem. C.Z. Chen Clark E.J. Expression Ichimura J.A. Jiang, Jones, M.F. M.L. Nat. Oncidium Onozaki, Petunia Phalaenopsis Recently, Rep. Rogers, S.F. Serek, Shimizu-Yumoto, Stummann, TF, Tanase, Woltering, Yamada, Zhou biology bold cDNA carnation, changes courier; delayed development effect em; enzymes expressed genes, induced insensitivity key longevity. mRNA mechanisms negative opening organ patterns perception physiology plants, pollination programmed pt;} regulatory results shown signal techniques transcriptional


Home
About
School
Lidership
History
Locations
Careers
Study
Undergraduate
Masters
International
Online
Research
Undergraduate research
Masters research
Funding
Something
Sub something
Sub something
Sub something
Sub something
News
Today
Calendar
Sport
Contact
School
Lidership
History
Locations
Careers
Study
Undergraduate
Masters
International
Online
Study
Undergraduate
Masters
International
Online
Empty sub
Star and fork on github
megamenu.js - Last responsive megamenu you'll ever need
Features:
IE8 Compatible (jquery animated)
No classes! (for dropdowns)
Smart - knows when to show megamenu
100% responsive
Seamless wordpress integration
Open source!


SUBROUTINE CLAED8( K, N, QSIZ, Q, LDQ, D, RHO, CUTPNT, Z, DLAMDA, $ Q2, LDQ2, W, INDXP, INDX, INDXQ, PERM, GIVPTR, $ GIVCOL, GIVNUM, INFO ) * * -- LAPACK routine (version 3.1) -- * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. * November 2006 * * .. Scalar Arguments .. INTEGER CUTPNT, GIVPTR, INFO, K, LDQ, LDQ2, N, QSIZ REAL RHO * .. * .. Array Arguments .. INTEGER GIVCOL( 2, * ), INDX( * ), INDXP( * ), $ INDXQ( * ), PERM( * ) REAL D( * ), DLAMDA( * ), GIVNUM( 2, * ), W( * ), $ Z( * ) COMPLEX Q( LDQ, * ), Q2( LDQ2, * ) * .. * * Purpose * ======= * * CLAED8 merges the two sets of eigenvalues together into a single * sorted set. Then it tries to deflate the size of the problem. * There are two ways in which deflation can occur: when two or more * eigenvalues are close together or if there is a tiny element in the * Z vector. For each such occurrence the order of the related secular * equation problem is reduced by one. * * Arguments * ========= * * K (output) INTEGER * Contains the number of non-deflated eigenvalues. * This is the order of the related secular equation. * * N (input) INTEGER * The dimension of the symmetric tridiagonal matrix. N >= 0. * * QSIZ (input) INTEGER * The dimension of the unitary matrix used to reduce * the dense or band matrix to tridiagonal form. * QSIZ >= N if ICOMPQ = 1. * * Q (input/output) COMPLEX array, dimension (LDQ,N) * On entry, Q contains the eigenvectors of the partially solved * system which has been previously updated in matrix * multiplies with other partially solved eigensystems. * On exit, Q contains the trailing (N-K) updated eigenvectors * (those which were deflated) in its last N-K columns. * * LDQ (input) INTEGER * The leading dimension of the array Q. LDQ >= max( 1, N ). * * D (input/output) REAL array, dimension (N) * On entry, D contains the eigenvalues of the two submatrices to * be combined. On exit, D contains the trailing (N-K) updated * eigenvalues (those which were deflated) sorted into increasing * order. * * RHO (input/output) REAL * Contains the off diagonal element associated with the rank-1 * cut which originally split the two submatrices which are now * being recombined. RHO is modified during the computation to * the value required by SLAED3. * * CUTPNT (input) INTEGER * Contains the location of the last eigenvalue in the leading * sub-matrix. MIN(1,N) <= CUTPNT <= N. * * Z (input) REAL array, dimension (N) * On input this vector contains the updating vector (the last * row of the first sub-eigenvector matrix and the first row of * the second sub-eigenvector matrix). The contents of Z are * destroyed during the updating process. * * DLAMDA (output) REAL array, dimension (N) * Contains a copy of the first K eigenvalues which will be used * by SLAED3 to form the secular equation. * * Q2 (output) COMPLEX array, dimension (LDQ2,N) * If ICOMPQ = 0, Q2 is not referenced. Otherwise, * Contains a copy of the first K eigenvectors which will be used * by SLAED7 in a matrix multiply (SGEMM) to update the new * eigenvectors. * * LDQ2 (input) INTEGER * The leading dimension of the array Q2. LDQ2 >= max( 1, N ). * * W (output) REAL array, dimension (N) * This will hold the first k values of the final * deflation-altered z-vector and will be passed to SLAED3. * * INDXP (workspace) INTEGER array, dimension (N) * This will contain the permutation used to place deflated * values of D at the end of the array. On output INDXP(1:K) * points to the nondeflated D-values and INDXP(K+1:N) * points to the deflated eigenvalues. * * INDX (workspace) INTEGER array, dimension (N) * This will contain the permutation used to sort the contents of * D into ascending order. * * INDXQ (input) INTEGER array, dimension (N) * This contains the permutation which separately sorts the two * sub-problems in D into ascending order. Note that elements in * the second half of this permutation must first have CUTPNT * added to their values in order to be accurate. * * PERM (output) INTEGER array, dimension (N) * Contains the permutations (from deflation and sorting) to be * applied to each eigenblock. * * GIVPTR (output) INTEGER * Contains the number of Givens rotations which took place in * this subproblem. * * GIVCOL (output) INTEGER array, dimension (2, N) * Each pair of numbers indicates a pair of columns to take place * in a Givens rotation. * * GIVNUM (output) REAL array, dimension (2, N) * Each number indicates the S value to be used in the * corresponding Givens rotation. * * INFO (output) INTEGER * = 0: successful exit. * < 0: if INFO = -i, the i-th argument had an illegal value. * * ===================================================================== * * .. Parameters .. REAL MONE, ZERO, ONE, TWO, EIGHT PARAMETER ( MONE = -1.0E0, ZERO = 0.0E0, ONE = 1.0E0, $ TWO = 2.0E0, EIGHT = 8.0E0 ) * .. * .. Local Scalars .. INTEGER I, IMAX, J, JLAM, JMAX, JP, K2, N1, N1P1, N2 REAL C, EPS, S, T, TAU, TOL * .. * .. External Functions .. INTEGER ISAMAX REAL SLAMCH, SLAPY2 EXTERNAL ISAMAX, SLAMCH, SLAPY2 * .. * .. External Subroutines .. EXTERNAL CCOPY, CLACPY, CSROT, SCOPY, SLAMRG, SSCAL, $ XERBLA * .. * .. Intrinsic Functions .. INTRINSIC ABS, MAX, MIN, SQRT * .. * .. Executable Statements .. * * Test the input parameters. * INFO = 0 * IF( N.LT.0 ) THEN INFO = -2 ELSE IF( QSIZ.LT.N ) THEN INFO = -3 ELSE IF( LDQ.LT.MAX( 1, N ) ) THEN INFO = -5 ELSE IF( CUTPNT.LT.MIN( 1, N ) .OR. CUTPNT.GT.N ) THEN INFO = -8 ELSE IF( LDQ2.LT.MAX( 1, N ) ) THEN INFO = -12 END IF IF( INFO.NE.0 ) THEN CALL XERBLA( 'CLAED8', -INFO ) RETURN END IF * * Quick return if possible * IF( N.EQ.0 ) $ RETURN * N1 = CUTPNT N2 = N - N1 N1P1 = N1 + 1 * IF( RHO.LT.ZERO ) THEN CALL SSCAL( N2, MONE, Z( N1P1 ), 1 ) END IF * * Normalize z so that norm(z) = 1 * T = ONE / SQRT( TWO ) DO 10 J = 1, N INDX( J ) = J 10 CONTINUE CALL SSCAL( N, T, Z, 1 ) RHO = ABS( TWO*RHO ) * * Sort the eigenvalues into increasing order * DO 20 I = CUTPNT + 1, N INDXQ( I ) = INDXQ( I ) + CUTPNT 20 CONTINUE DO 30 I = 1, N DLAMDA( I ) = D( INDXQ( I ) ) W( I ) = Z( INDXQ( I ) ) 30 CONTINUE I = 1 J = CUTPNT + 1 CALL SLAMRG( N1, N2, DLAMDA, 1, 1, INDX ) DO 40 I = 1, N D( I ) = DLAMDA( INDX( I ) ) Z( I ) = W( INDX( I ) ) 40 CONTINUE * * Calculate the allowable deflation tolerance * IMAX = ISAMAX( N, Z, 1 ) JMAX = ISAMAX( N, D, 1 ) EPS = SLAMCH( 'Epsilon' ) TOL = EIGHT*EPS*ABS( D( JMAX ) ) * * If the rank-1 modifier is small enough, no more needs to be done * -- except to reorganize Q so that its columns correspond with the * elements in D. * IF( RHO*ABS( Z( IMAX ) ).LE.TOL ) THEN K = 0 DO 50 J = 1, N PERM( J ) = INDXQ( INDX( J ) ) CALL CCOPY( QSIZ, Q( 1, PERM( J ) ), 1, Q2( 1, J ), 1 ) 50 CONTINUE CALL CLACPY( 'A', QSIZ, N, Q2( 1, 1 ), LDQ2, Q( 1, 1 ), LDQ ) RETURN END IF * * If there are multiple eigenvalues then the problem deflates. Here * the number of equal eigenvalues are found. As each equal * eigenvalue is found, an elementary reflector is computed to rotate * the corresponding eigensubspace so that the corresponding * components of Z are zero in this new basis. * K = 0 GIVPTR = 0 K2 = N + 1 DO 60 J = 1, N IF( RHO*ABS( Z( J ) ).LE.TOL ) THEN * * Deflate due to small z component. * K2 = K2 - 1 INDXP( K2 ) = J IF( J.EQ.N ) $ GO TO 100 ELSE JLAM = J GO TO 70 END IF 60 CONTINUE 70 CONTINUE J = J + 1 IF( J.GT.N ) $ GO TO 90 IF( RHO*ABS( Z( J ) ).LE.TOL ) THEN * * Deflate due to small z component. * K2 = K2 - 1 INDXP( K2 ) = J ELSE * * Check if eigenvalues are close enough to allow deflation. * S = Z( JLAM ) C = Z( J ) * * Find sqrt(a**2+b**2) without overflow or * destructive underflow. * TAU = SLAPY2( C, S ) T = D( J ) - D( JLAM ) C = C / TAU S = -S / TAU IF( ABS( T*C*S ).LE.TOL ) THEN * * Deflation is possible. * Z( J ) = TAU Z( JLAM ) = ZERO * * Record the appropriate Givens rotation * GIVPTR = GIVPTR + 1 GIVCOL( 1, GIVPTR ) = INDXQ( INDX( JLAM ) ) GIVCOL( 2, GIVPTR ) = INDXQ( INDX( J ) ) GIVNUM( 1, GIVPTR ) = C GIVNUM( 2, GIVPTR ) = S CALL CSROT( QSIZ, Q( 1, INDXQ( INDX( JLAM ) ) ), 1, $ Q( 1, INDXQ( INDX( J ) ) ), 1, C, S ) T = D( JLAM )*C*C + D( J )*S*S D( J ) = D( JLAM )*S*S + D( J )*C*C D( JLAM ) = T K2 = K2 - 1 I = 1 80 CONTINUE IF( K2+I.LE.N ) THEN IF( D( JLAM ).LT.D( INDXP( K2+I ) ) ) THEN INDXP( K2+I-1 ) = INDXP( K2+I ) INDXP( K2+I ) = JLAM I = I + 1 GO TO 80 ELSE INDXP( K2+I-1 ) = JLAM END IF ELSE INDXP( K2+I-1 ) = JLAM END IF JLAM = J ELSE K = K + 1 W( K ) = Z( JLAM ) DLAMDA( K ) = D( JLAM ) INDXP( K ) = JLAM JLAM = J END IF END IF GO TO 70 90 CONTINUE * * Record the last eigenvalue. * K = K + 1 W( K ) = Z( JLAM ) DLAMDA( K ) = D( JLAM ) INDXP( K ) = JLAM * 100 CONTINUE * * Sort the eigenvalues and corresponding eigenvectors into DLAMDA * and Q2 respectively. The eigenvalues/vectors which were not * deflated go into the first K slots of DLAMDA and Q2 respectively, * while those which were deflated go into the last N - K slots. * DO 110 J = 1, N JP = INDXP( J ) DLAMDA( J ) = D( JP ) PERM( J ) = INDXQ( INDX( JP ) ) CALL CCOPY( QSIZ, Q( 1, PERM( J ) ), 1, Q2( 1, J ), 1 ) 110 CONTINUE * * The deflated eigenvalues and their corresponding vectors go back * into the last N - K slots of D and Q respectively. * IF( K.LT.N ) THEN CALL SCOPY( N-K, DLAMDA( K+1 ), 1, D( K+1 ), 1 ) CALL CLACPY( 'A', QSIZ, N-K, Q2( 1, K+1 ), LDQ2, Q( 1, K+1 ), $ LDQ ) END IF * RETURN * * End of CLAED8 * END


Project: Is it edible?
Exams are over, so I’ve decided to post some of the projects I’ve made, but haven’t posted on here.
This was one that I made at SB Hacks, my first hackathon! Great times, new friends, and so much cool stuff! It was definitely an experience I won’t forget!
Anyway, I was playing around with the Clarifai API, which does image recognition, and I got the idea to combine this API with Wordnet, to create a program that can tell if something is edible.
Basically, it takes in an image, uses Clarifai to generate a set of terms that it thinks best describes the image (Computer Vision is awesome!), then looks it up in Wordnet, finds out if these words are in the “Food” category, then returns the probability that it’s edible.
An example: Let’s say I have this cake image in the same folder as the code, named “cake.jpg”
Then, I can run the code as so:
It will give the output:
The first line of output is a list of possible objects in the image, which it is surprisingly accurate about. The second line is the calculated probility that the object depicted in the image is edible, and it’s right! Of course a cake is perfectly edible!
 So here’s the code:


--- layout: page title: About header-img: "img/about-bg.png" ---
Aspiring data scientist, arriving here via archaeology, statistics, venture capital, startups and product management.


An example of creating, deploying and leveraging a set of rules (decision table) in a Realtime Decision Server. Shows calling the rules as if using it from an application with the RestAPI that is exposed.
This demo project is a demonstration application of a stateless Realtime Decision Server based on JBoss BRMS and includes support for complex event processing (CEP) use cases based on a pseudo clock.


Toggle navigation
GC-IGS
ADMIN
Online
Home
Students
Subject
Billing
Logout
Dashboard
Student
Add Student
Students
Student No
Firstname
Lastname
Department
Action


In each round, you will be grouped randomly and anonymously with several other participants.
Each participant has three possible statuses: “waiting in the line”, “in service”, and “served”.
The round will be divided into several periods, where each period encompasses one player’s service turn. At the beginning of each round (the first period starts),
every participant is “waiting in the line” and they can start to exchange positions with the participants immediately next to them.
You cannot interact with someone who is already interacting with the person in front of them; otherwise, you may initiate an interaction with said person.
At the end of the first period, the first participant in the line will go to the service room, others remain in the line and the second period will start.
The service for each participant will take one period (20 seconds) and the round ends when all participants have finished the service.
How your payoff is calculated
Your payoff in each round will be given by E + V - (n-1)*C + T , where n is the order or place in which you are served.
E (Endowment) is the value you have at the beginning of each period.
V (Value) is the value of the service, which will be applied to a player’s point total only after they have finished their service turn.
C (Cost) is the time cost per period which will be deducted from a player’s point total after each period they participate in that does not send them to the service room.
C will be determined randomly for each player in each period.
T (trade) is the sum of all transfers you receive minus all transfers you make from trading or exchanging places with others under some rules.
The rule you are currently playing: Swap
You can ask the participant directly in front of you to exchange positions.
The requester needs to either accept or decline your exchange request.
You may also receive the exchange request from participants directly behind you.


This milestone is characterized by the contract agreement between stakeholders and developers on the implementation and scope details and Viva Vigan! Application content.
This milestone is characterized by the release of the first working application, as has been defined in the contract agreement. The content of the first release includes the major modules of the application like Attractions, Foods, Accommodations and Events, as well as both the Android and Web applications for its administrators.
Development of iOS Application This milestone is characterized by the implementation of the iOS application development and release of initial modules.
This milestone is characterized by the implementation of the remaining features in both mobile and web applications, as agreed upon in the contract agreement.
This milestone is characterized by the support and mintenance of the applications, as well as documentations and minor feature updates.
Full Stack Developer
Nick obtained his Bachelor's degree in Computer Science from Mariano Marcos State University. Viva Vigan! is his first deployed application, aided with over two years of experience in the Corporate Software Engineering, serving both international and local clients in various sectors.
Email<EMAIL_ADDRESS>Text or Call: +63<PHONE_NUMBER>


Software development is done differently at every organization, and in every home office throughout the world. The process that one organization or person uses to develop software may work for their specific environment and situation, but may fail miserably in another set of circumstances.
However, despite these changes there are some things that remain the same. There will always be a need to understand the business problem, convert that problem into an architecture, convert the architecture into a solution, test the solution, and deploy the solution. Although each of these processes may change to some extent based on the programming models and tools being used, fundamentally there are some roles which every process has in one form or another. One person may be filling all the roles or a handful of the roles, or one very specific role. Despite this there is a need for all of the roles - each serves a purpose. The organization chart below gives you an idea of how each position fits together within an organization.
There is a series of roles that exist in most software development processes. As mentioned above one team member may be filling many roles and some roles may be suppressed for a specific type of project but all of these roles exist in one form or another in every software development project:
The subject matter expert is the person or persons from which requirements are captured. These are the people who know what the software needs to do and how the process works. The SME role is somewhat different from the other roles because it is constantly changing as new clients (internal or external) are brought in to help design a solution. SMEs are rarely from IT - except when the solution is being designed to support IT. SMEs are most frequently the person who will receive the benefit of the system.
Functional analysts have the unenviable roles of eliciting clear, concise, non-conflicting requirements from the Subject Matter Experts who may or may not understand how technology can be used to transform the business processes in a positive way.
The technical architect is responsible for transforming the requirements created by the Functional Analysts into a set of architecture and design documents that can be used by the rest of the team to actually create the solution. The Solutions Architect is typically responsible for matching technologies to the problem being solved.
The development lead's role is focused around providing more detail to the Solution Architect's architecture. This would include detailed program specifications creation. The Development Lead is also the first line of support for the developers who need help understanding a concept or working through a particularly thorny issue.
The heart and soul of the process, the developer actually writes the code that the Development Leads provided specifications for.
The quality assurance role is an often thankless position that is designed to find bugs before they find their way to the end customers. Using a variety of techniques ranging from keying in data and playing with the system to formalized to automated testing scripts, the Quality Assurance team is responsible for ensuring the quality of the solution and it's fit to the requirements gathered by the Functional Analyst. Sometimes the QA team is known by their less flattering name of testers.
The deployment role is the one which packages up all of the compiled code and configuration files and deploys it through the appropriate environments or on the appropriate systems. The deployment role is focused on getting the solution used. To that end the role may include automated software installation procedures or may be as simple as copying the files to the appropriate place and running them.
The training role is responsible for documentation for the system as well as any instructor or computer based training solutions, which are designed to help the users better understand how the system works and what they can do with it.
The project manager is responsible for ensuring consistent reporting, risk mitigation, timeline, and cost control. The project manager role is a problem solver role. They try to resolve problems why they are small so that they can be handled more quickly and with less cost.
The development manager is responsible for managing multiple priorities of conflicting projects. The Development Manager role is also an escalation for issues from the team, which it is unable to resolve internally.
A set of skills was identified to be essential business skills that professionals in nearly every role needed to consider during their career.
Although some roles are focused very specifically around certain aspects of understanding and converting business requirements, every role in the process should have an awareness and sensitivity to the business processes and needs which require technology in the first place. Without this technology may be implemented but it may not solve the real needs and will therefore be considered a failure.
Although an understanding of software development is critical there are other areas where an understanding can be invaluable. For instance, understanding how computers work internally including memory, cache, hard drives, etc., can help you learn how to more appropriately conserve those resources. Similarly understanding networking can help in the development of applications, which are compatible or even friendly to the networks that they're working across. SMEs broad understanding of the industry can be invaluable in terms of creating solutions that fit both the organization and the industry. The QA team can benefit the project by a broad understanding by minimizing QA costs while improving testing coverage. In short, a broad understanding can help every role.
The ability to approach solutions from multiple perspectives is critical to software development. Understanding how each person who is working on a problem views an issue - or how different customers will view the solution is important to be able to find the best solution based on all of the information. There are always multiple ways of viewing - and solving - a problem. The trick is to find the best one from the list of possible options. The larger the list of options (perspectives) the better the solution.
Also known as soft skills, the ability to interact with other people and to be a part of a team is essential to nearly every role in a software development project. The lower the overall people skills of the team the higher the likelihood that the project will end in some explosion.


Our mission at Huddle Up is to make sure our users are satisfied with our website and are able to make time to hang out with there friends without having to worry about if they have plans or a busy schedule that day. We want our users to be able to have a good time and with the help of our website it is easy to show you days that you are free to met up and at what time that you are available
Creators of Huddle Up
Mahlet Copeland
Tina Black
- My name is Tina Black and I will be going into the 11th grade at San Leandro High School. In my free time, I like to paint or write what I am feeling. I am currently in Girls Inc, Girls Who Code Summer Immersion Program, and I also had an internship at the Oakland Police Department (OPD). When I get older, I want to work in the Criminal Justice Field.
Anne Huang
Monica Chavez


Salary Calculator
Add Employee:
Submit
Undo Deletion
Employees:
First Name
Last Name
ID
Title
Annual Salary
Remove Employee
Total Monthly: $


Lyuba's Notes
Lyuba's Notes
The Basics of the Web and HTML
The web is a bunch of computers that communicate with each other.
When a person goes to a web page like www.google.com, their computer sends a HTTP Request to a server. The server finds the appropriate HTML document and sends it back to the user's computer where a web browser interprets the page and displays it on the user's screen.
HTML – Hyper Text Markup Language
HTML is made up of:
- Text content -> what you see
- Markup -> what it looks like
- References to -> e.g. images + videos
- Links to other pages
HTML Markup
(<name>content</name>) - ELEMENT
<name> - opening tag
</name> - closing tag
Types of HTML Elements
- Inline - an inline element occupies only the space bounded by the tags that define the inline. Generally, inline elements may contain only data and other inline elements. By default, inline elements do not begin with new line.
- block - block elements form an "invisiible box" around the content outside of them. By default, block elements begin with a new line
Tree-like structure of HTML
The "tree-like structure" comes from the fact that HTML elements can have other elements inside of them.
In a browser, this structure shows up as a series of nested boxes. There are boxes inside of boxes inside of boxes, and so on...
Relationships between indented HTML and boxes
When you read an HTML document as text, you see a wave of changing indentations going up and down the left side of the document. The more indented an element is, the more deeply nested it's corresponding "box" is.
The Box Model
Box Sizing
- HTML elements are boxes and each box has 4 components
- Because the are so many components to each box, it can pften be hard to get the box just right
-
There are two techniques you can use to help deal with sizing issues:
- Set sizes in terms of percents rather than pixels
- Set the box-sizing attribute to border-box for every element
- Different browsers work slightly differently. Sometimes this causes different browsers to display the same code differently
Box Positioning
- Divs are block elements (as opposed to inline), so by default they take up the entire width of a page
- Adding the rule display: flex; to the appropriate CSS will override this behavior and let divs appear next to each other
Cascading Style Sheets (CSS)
CSS is code written to control the "style" of HTML elements.
Descendant elements may inherit CSS property values from any ancestor element enclosing them.
Cascading
The rules are applied not only to the elements they directly match but also to all those elements’ child elements.
Avoid Repetition
- The most specific rule is applied to every element
- Inheritance is the mechanism by which properties are applied not only to a specified element, but also to its descendants.
- Relies on the document tree. Descendant elements may inherit CSS property values from any ancestor element enclosing them.
- Descendant elements inherit text-related properties, but box-related properties are not inherited.
Properties that can be inherited are color, font, letter-spacing, line-height, list-style, text-align, text-indent, text-transform, visibility, white-space and word-spacing.
Properties that cannot be inherited are background, border, display, float and clear, height and width, margin, min- and max-height and -width, outline, overflow, padding, position, text-decoration, vertical-align and z-index.
NOTE: If a chilld element has multiple overlapping rules defined for it, the more specific rule takes effect.
CSS Styling of a Page
There are several methods for applying styles to a HTML document.
Method 1
Write CSS in the <head> of the HTML. This method is suitable for small projects.
Method 2
Link the HTML to a separate CSS file. This method helps to stay more organized when working on big projects.
Method 3
Write styles inline with the HTML using the "style" attribute. This method is not recommended becasuse it causes a lot of code repetition.
CSS Selectors
Code, Test, Refine
- Look for natural boxes\
- Look for repeated styles and semantic elements
- Write your HTML
- Apply styles (from biggest to smallest)
- Fix things


Number of sides:
Jump size
Skip (+ or -)
Subdivide polygon
Edges/division
Alternate direction
Colour


Google Code offered in: English - Español - 日本語 - 한국어 - Português - Pусский - 中文(简体) - 中文(繁體)
At this point, you've finished implementing the StockWatcher UI and all its client-side functionality. However, you've noticed that there is an error in the Change field. The percentage of change is not calculating correctly.
In this section, you'll use Eclipse to debug your Java code while running StockWatcher in development mode.
You can debug the Java source code before you compile it into JavaScript. This GWT develpment process help you take advantage of the debugging tools in your Java IDE. You can:
One of attractions of developing in JavaScript is that you can make changes and see them immediately by refreshing the browser—without having to do a slow compilation step. GWT development mode provides the exact same development cycle. You do not have to recompile for every change you make; that's the whole point of development mode. Just click "Refresh" to see your updated Java code in action.
Looking at the values in the Price and Change fields, you can see that, for some reason, all of the change percentages are only 1/10 the size of the correct values.
The values for the Change field are loaded by the updateTable(StockPrice) method.
/** * Update a single row in the stock table. * * @param price Stock data for a single row. */ private void updateTable(StockPrice price) { // Make sure the stock is still in the stock table. if (!stocks.contains(price.getSymbol())) { return; } int row = stocks.indexOf(price.getSymbol()) + 1; // Format the data in the Price and Change fields. String priceText = NumberFormat.getFormat("#,##0.00").format( price.getPrice()); NumberFormat changeFormat = NumberFormat.getFormat("+#,##0.00;-#,##0.00"); String changeText = changeFormat.format(price.getChange()); String changePercentText = changeFormat.format(price.getChangePercent()); // Populate the Price and Change fields with new data. stocksFlexTable.setText(row, 1, priceText); stocksFlexTable.setText(row, 2, changeText + " (" + changePercentText + "%)"); }
Just glancing at the code, you can see that the value of the changePercentText variable is being set elsewhere, in price.getChangePercent. So, first set a breakpoint on that line and then drill down to determine where the error in calculating the change percentage is.
String changePercentText = changeFormat.format(price.getChangePercent());
stocksFlexTable.setText(row, 1, priceText);
Now step into the code to see where and how the changePercentText is being calculated.
public double getChangePercent() { return 10.0 * this.change / this.price; }
Looking at the getChangePercent method, you can see the problem: it's multiplying the change percentage by 10 instead of 100. That corresponds exactly with the output you saw before: all of the change percentages were only 1/10 the size of the correct values.
public double getChangePercent() {
return 100.0 * this.change / this.price;
}
Tip: In Eclipse, if you find it easier to edit in the Java perspective rather than the Debug perspective, you can switch back and forth while running StockWatcher in development mode.
At this point when you enter a stock code, the calculation of the Change field should be accurate. Try it and see.
At this point you've implemented all your functional requirements. StockWatcher is running and you've found and fixed a bug.
Now you're ready to enhance StockWatcher's visual design. You'll apply CSS style rules to the GWT widgets and add a static element (a logo) to the page.