--- layout: post title: "A reading of Extensibility for the Masses" description: "A paper read and translated to C#." date: 2021-07-12 5:36 UTC tags: [Software Design, Design Patterns] --- {% include JB/setup %}
{{ page.description }}
When I have the time (and I do make this a priority) I set aside an hour every day to study. Lately I've been using these time slots to read and reproduce the code in the 2012 paper "Extensibility for the Masses. Practical Extensibility with Object Algebras" by Bruno C. d. S. Oliveira and William R. Cook. As is often common with academic papers, they don't have a single, authoritative address on the internet. You can find the paper in various places. I've used a copy hosted by University of Texas, which is the institution with which William R. Cook is associated.
While the example code in the paper is in Java, the authors claim that it translates easily to C#. I decided to give this a try, and found it to be true.
From the beginning I created a Git repository with an eye to publishing it in case anyone was interested in looking over my shoulder. Not only can you see the 'final' translation, but you can also follow along with each commit.
I committed each time I had something that seemed to work. When I struggled to understand how to interpret some of the code, I left detailed commit messages describing my doubts, and explaining why I had chosen to interpret things in a particular way.
Along the way I also added automated tests, because I found that the paper lacked examples. Those tests represent my own interpretation of the code in the paper, and how one is supposed to use it. In total, I wrote 75 test cases.
At one time I hit a snag that I couldn't readily resolve. After searching the web in vain, I posted a question on Stack Overflow. After a few days, I got an answer from Bruno C. d. S. Oliveira, one of the authors of the paper!
It turns out that some of my confusion stemmed from an otherwise inconsequential error in the paper. We shouldn't be shocked that an academic paper contains errors. One of many things I learned from reading Charles Petzold's excellent book The Annotated Turing was that later researchers found several errors in Turing's 1936 paper, but none that changed the overall conclusion. So it seems to be here as well. There's at least one confirmed error (and another one that I only suspect), but it's inconsequential and easily corrected.
It does, however, raise a point about scientific papers in general: Even if they're peer-reviewed they may contain errors. I'm much in favour of scientific knowledge, but also sceptical about some claims about computer science and software engineering.
The paper's title claims to give extensibility to the masses, but will 'the masses' be able to read the paper? As papers go, I found this one quite readable. While other papers present their examples in Haskell, this one uses Java. If you're comfortable with Java (or C#), you should be able to follow the code examples (or my C# translation).
You won't entirely escape Greek letters or other abstruse nomenclature. This is, after all, an academic paper, so it can't be lucid all the way through. There's a section called Algebraic Signatures, F-Algebras, and Church Encodings that is definitely not for 'the masses'. I understand enough about F-algebras and Church encodings to follow the outline of this section, but I didn't find it helpful.
If you're interested in the overall article, but don't know what these words mean, I suggest you skim those parts and pay as much attention to the details as when Geordi La Forge spews technobabble. In other words, I think you can follow the rest of the article just was well, even if ChurchΣ = ∀A.(T1 → A) × ... × (Tn → A) → A makes no sense to you.
Does the paper deliver on its promise? Yes and no. Formally, I think that it does. In the beginning, it establishes some criteria for a successful solution, and as far as I can tell, it can check off all of them.
It's also true that the proposed solution requires only intermediary language features. Generics and inheritance, as they're available in C# and Java, is all that's required.
On the other hand, I don't find the paper's examples compelling. Few 'mass developers' are tasked with implementing a simple expression-based language. I can't shake the feeling that most of what the paper accomplishes could be handled with tasty application of composition and the Adapter pattern.
Still, I'll keep this paper in mind if I ever have to publish a reusable and extensible, type-safe software library.
Comments
I was intrigued by the paper's abstract, but then it turned out it's just about implementing Oleg Kiselyov's final (typed, tagless) encoding in plain boring Java/C# — the most surprising thing is that it doesn't really mention Kiselyov's work which predates this paper by 3-4 years. And Kiselyov in his writings moslty used really basic Haskell features so translating it to Java/C# is pretty straightforward, I actually did with it the last Autumn, toying with the idea, so I feel this paper could very well have been a (small) blog post, really. Anyway, let's talk about the proposed solution itself.
And the solution is actually pretty ingenious! The conventional approach to representing AST and writing interpreters (in broad sense) for it is to represent AST as a tree of objects, and interpret it by walking this tree over, doing the work in the process. The problem is that to add a new kind of node to AST you need to patch all existing intepreters, and writing an interpreter involves either manual dynamic dispatch on the node types in the interpreter's code, or trying to shift it onto the nodes itself somehow (cf. Visitor pattern).
The proposed solution neatly side steps the whole problem of representing an AST by simply not representing it as a piece of data at all, it instead interprets a (would-be) AST right at the moment of the construction. And so the interpreters — instead of being written as vistors — are written as builders that build the resulting value.
As I said, it's very ingenious but it is also, sadly, largely pointless. You see, it all largely started with the Haskell programmers trying to make ASTs more statically typed to get rid of as many runtime checks and "this case is impossible" in switches in the interpreters: you have to check that e.g. the
if
's condition (which is usually just a plainExpr
) must evaluate to boolean, but if you make its type some sort ofExpr<BoolType&rt;
, the Haskell's typechecker won't allow you to build a malformed AST in the first place! It led to introduction of GADTs, then to extending GADTs even further, and I guess at some point some people started feeling kinda uneasy about going this close to the full-blown dependent types, and so the tagless final encoding was born: as I said in the beginning, it uses very boring and straightforward Haskell features — parametric polymorphism and typeclasses — or, as they're more widely known, generics and interfaces. But then again, as it evolved, it too started require language extensions although not as radical as in previous cases, and at some point waded into the esoteric type-level meta-programming territory.So here's the pointless part: the initial goal was to push type-checking of the (mini-)language being implemented onto the Haskell's typechecker, and it makes implementing small, typed mini-languages that are essentially Haskell's subset very easy, but... if you program in Haskell, what do you need this toy of a language for? And do its types/semantics really align that well with Haskell's? If they don't, this whole ordeal becomes very difficult: imagine a language with three variables (
A
,B
, andC
) that can hold either integers or booleans, constants, assignments, basic arithmetic and comparison operators,if-then-else
statement andwhile
loop. Trying to encode it in Haskell type-safely (so that variables would have consistent types after all branches/loops' ends) is pretty non-trivial, whether you use GADTs or the approach from the paper. I've seen a blogpost where this exact excercise was done, and it was done in Coq, with essential use of dependent typing.And trying to pull this off in a language like Java/C# with much more limited type-system is, I would argue, fundamentally misguided. Eric Lippert has summed it quite well in his "Wizards and warriors, part five":
Then, of course, there is a problem that in this approach, AST does not actually exist as an object: it's represented as a function/method. If the interpreter you write needs multiple passes over AST, I am afraid you'll have to materialize your AST and AFAIK you can't really fine-tune or optimize the representation of closures in Java/C#. Of course, if you don't need multiple passes, then this approach is perfectly fine, and in fact, that's actually how one-pass compilers are usually structured: the parser straight up calls the code-generating hooks, and when it's done, the code-gen is done.
And when it comes down to actual extensibility, that is, the case when a new node type is added to AST, this approach really doesn't win much compared to conventional visitors: ideally, since interfaces should be immutable, such addition means that a new visitor interface is declared (an extension of the old one) which can be implemented by inheriting from the old interpreter, or by Adapting it — just the same that would be done in the proposed approach.
So, my conclusion: this paper tries to solve the problem of AST representation/interpretation by telling us to essentially write one-pass compilers, in the name of not writing semantic checking code for AST ourselves but instead of shifting it onto the shoulders of Java/C# type checker. No, sorry, but that's not a solution to the actual problem.


Copyright 2006-2011 University of Amsterdam, Jurriaan H. Spaaks & Scott L. Davis
Copyright (c) 2012, Scott L. Davis
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.


|
MQTTClient
an Objective-C Framework for MQTT
|
#import <MQTTSession.h>
Instance Methods | |
| (void) | - newMessage:data:onTopic:qos:retained:mid: |
| (void) | - session:newMessage:onTopic: |
| (void) | - handleEvent:event:error: |
| (void) | - session:handleEvent: |
| (void) | - connected: |
| (void) | - connected:sessionPresent: |
| (void) | - connectionRefused:error: |
| (void) | - connectionClosed: |
| (void) | - connectionError:error: |
| (void) | - protocolError:error: |
| (void) | - messageDelivered:msgID: |
| (void) | - subAckReceived:msgID:grantedQoss: |
| (void) | - unsubAckReceived:msgID: |
| (void) | - sending:type:qos:retained:duped:mid:data: |
| (void) | - received:type:qos:retained:duped:mid:data: |
| (void) | - buffered:queued:flowingIn:flowingOut: |
Session delegate gives your application control over the MQTTSession
|
optional |
gets called when the content of MQTTClients internal buffers change use for monitoring the completion of transmitted and received messages
| session | the MQTTSession reporting the change |
| queued | the number of queued messages waiting to be send when the connection becomes established and ready |
| flowingIn | the number of incoming messages not acknowledged by the MQTTClient yet |
| flowingOut | the number of outgoing messages not yet acknowledged by the MQTT broker |
|
optional |
gets called when a connection has been successfully established
| session | the MQTTSession reporting the connect |
|
optional |
gets called when a connection has been successfully established
| session | the MQTTSession reporting the connect |
| sessionPresent | represents the Session Present flag sent by the broker |
|
optional |
gets called when a connection has been closed
| session | the MQTTSession reporting the close |
|
optional |
gets called when a connection error happened
| session | the MQTTSession reporting the connect error |
| error | an optional additional error object with additional information |
|
optional |
gets called when a connection has been refused
| session | the MQTTSession reporting the refusal |
| error | an optional additional error object with additional information |
|
optional |
gets called when a connection is established, closed or a problem occurred
| session | the MQTTSession reporting the event |
| eventCode | the code of the event |
| error | an optional additional error object with additional information |
|
optional |
gets called when a published message was actually delivered
| session | the MQTTSession reporting the delivery |
| msgID | the Message Identifier of the delivered message |
|
optional |
gets called when a new message was received
| session | the MQTTSession reporting the new message |
| data | the data received, might be zero length |
| topic | the topic the data was published to |
| qos | the qos of the message |
| retained | indicates if the data retransmitted from server storage |
| mid | the Message Identifier of the message if qos = 1 or 2, zero otherwise |
|
optional |
gets called when an MQTT protocol error happened
| session | the MQTTSession reporting the protocol error |
| error | an optional additional error object with additional information |
|
optional |
gets called when a command is received from the MQTT broker use this for low level monitoring of the MQTT connection
| session | the MQTTSession reporting the received command |
| type | the MQTT command type |
| qos | the Quality of Service of the command |
| retained | the retained status of the command |
| duped | the duplication status of the command |
| mid | the Message Identifier of the command |
| data | the payload data of the command if any, might be zero length |
|
optional |
gets called when a command is sent to the MQTT broker use this for low level monitoring of the MQTT connection
| session | the MQTTSession reporting the sent command |
| type | the MQTT command type |
| qos | the Quality of Service of the command |
| retained | the retained status of the command |
| duped | the duplication status of the command |
| mid | the Message Identifier of the command |
| data | the payload data of the command if any, might be zero length |
|
optional |
gets called when a subscription is acknowledged by the MQTT broker
| session | the MQTTSession reporting the acknowledge |
| msgID | the Message Identifier of the SUBSCRIBE message |
| qoss | an array containing the granted QoS(s) related to the SUBSCRIBE message (see subscribeTopic, subscribeTopics) |
|
optional |
gets called when an unsubscribe is acknowledged by the MQTT broker
| session | the MQTTSession reporting the acknowledge |
| msgID | the Message Identifier of the UNSUBSCRIBE message |


Zika virus women healthcare health access Health services infection {border-style participants pregnant information px;} #ffffff;} study ;:–. collab: public Accessed August guidelines affected care consequences lack pregnancy epidemic knowledge out�?of�?pocket prenatal national payments provided cases included microcephaly pregnancy. risk virus. Social confirmed interviews mentioned possible px; suspected website]. {font-family Colombia Colombia. Ministry Organization Protection Villavicencio, age clinical did experiences follow�?up font-size including infection. poor reported results timely virus, No. World accessing associated conducted double; gaps general identified management need neurologic performed pregnancy, prevention set surveillance :–. Health. National Public Villavicencio border-color border-width categories conceptual education framework future given high infected knew municipality newborns participant population present qualitative research services, signs solid; study. test transmission used using {font-style {font-weight Colombian December Engl Institute Med. Table Virus Women administrative analysis approach article availability basic bold congenital context contributed counseling courier; delayed different disease em; fetus improve infection, institutions larger main medical municipalities needs obtained outbreak procedures project providers provision pt;} questions recognized reduce referred reproductive sequelae services. severe strategies strategies, termination tests time total transmission, voluntary woman


assigned
by James R. Griffin III at 2020-05-08 06:05:41.This is fairly far along, I'm going to try and extend the scope of this to cover all Classes in the code base. I have some thoughts regarding the documenting of routines, but I will create a new GitHub issue in order to discuss these.
This completes all documentation for classes and methods declared in this project (please see https://inch-ci.org/github/pulibrary/dspace-cli?branch=yard-cli-dir&pending_build=578469).
However, as one can observe, there are a number of undocumented routines which are provided by dspace-cli. Given that these are not intended to serve as an API?
mentioned
by Kevin McElwee at 2020-05-08 21:05:03.subscribed
by Kevin McElwee at 2020-05-08 21:05:03.referenced
by Kevin McElwee at 2020-05-08 13:38:58.merged
by Kevin McElwee at 2020-05-08 13:38:58.closed
by Kevin McElwee at 2020-05-08 13:38:58.This is really excellent, thank you cleaning much of this.
renamed
by James R. Griffin III at 2020-05-08 14:20:55.base_ref_changed
by James R. Griffin III at 2020-05-08 14:21:07.head_ref_force_pushed
by James R. Griffin III at 2020-05-08 14:21:50.ready_for_review
by James R. Griffin III at 2020-05-08 14:21:59.no longer needed due to BE upgrade.
closed
by None at 2020-05-08 13:47:38.assigned
by None at 2020-05-08 14:29:26.renamed
by None at 2020-05-08 14:36:06.labeled
by Trey Pendragon at 2020-05-08 17:53:18.labeled
by Trey Pendragon at 2020-05-08 18:00:01.referenced
by Trey Pendragon at 2020-05-08 18:09:04.merged
by Trey Pendragon at 2020-05-08 18:09:04.closed
by Trey Pendragon at 2020-05-08 18:09:05.head_ref_deleted
by Trey Pendragon at 2020-05-08 18:09:08.referenced
by Eliot Jordan at 2020-05-08 18:24:36.merged
by Eliot Jordan at 2020-05-08 18:24:36.closed
by Eliot Jordan at 2020-05-08 18:24:36.head_ref_deleted
by Eliot Jordan at 2020-05-08 18:24:39.labeled
by Eliot Jordan at 2020-05-08 18:53:39.@hackmastera Bah! Fixed, thanks for the ping.
head_ref_force_pushed
by Trey Pendragon at 2020-05-08 19:26:30.mentioned
by None at 2020-05-08 19:26:34.subscribed
by None at 2020-05-08 19:26:34.referenced
by None at 2020-05-08 19:50:40.merged
by None at 2020-05-08 19:50:40.closed
by None at 2020-05-08 19:50:40.head_ref_deleted
by None at 2020-05-08 19:50:44.head_ref_force_pushed
by Eliot Jordan at 2020-05-08 20:01:04.referenced
by Eliot Jordan at 2020-05-08 20:32:42.merged
by Eliot Jordan at 2020-05-08 20:32:42.closed
by Eliot Jordan at 2020-05-08 20:32:42.head_ref_deleted
by Eliot Jordan at 2020-05-08 20:32:45.@kelea99 We'll try to get this done next week.
mentioned
by Kim Leaman at 2020-05-08 20:51:32.subscribed
by Kim Leaman at 2020-05-08 20:51:32.convert_to_draft
by James R. Griffin III at 2020-05-08 21:00:30.we cannot configure yet the locations in Alma according to @mzelesky and @kevinreiss. we will ask exlibris on basecamp.
https://github.com/pulibrary/marc_liberation/blob/8e94c719050fde74a6796b3ccf92264eec6e17c6/app/controllers/availability_controller.rb#L126 'Order Received',: Closed https://knowledge.exlibrisgroup.com/Alma/Product_Documentation/010Alma_Online_Help_(English)/020Acquisitions/020Purchasing/045Closing%2C_Reopening%2C_and_Relinking_PO_Lines#Closing_PO_Lines 'Pending Order': Waiting for invoice 'On-Order': Ready @mzelesky can you confirm if these values are correct?
Statuses that map to 'Order Received' in liberator: Waiting for Manual Renewal Waiting for Renewal Waiting for Invoice
Statuses that map to 'Pending Order' in liberator: In Review Manual Packaging Auto Packaging Ready
All other statuses map to 'On-Order'. This is pending further discussion with Acquisitions, but these are the definitions to use for now.
assigned
by Christina Chortaria at 2020-05-08 14:02:17.mentioned
by None at 2020-05-08 14:11:53.subscribed
by None at 2020-05-08 14:11:53.referenced
by Kevin Reiss at 2020-05-08 14:43:15.merged
by Kevin Reiss at 2020-05-08 14:43:15.closed
by Kevin Reiss at 2020-05-08 14:43:15.head_ref_deleted
by Kevin Reiss at 2020-05-08 14:43:18.head_ref_force_pushed
by None at 2020-05-08 14:44:17.export data from production on lib-mudd-prod1
ssh deploy@lib-mudd-prod1
more ~deploy/app_configs/mudd-dbs
mysqldump -h <IP_ADDRESS> -u mudd-prod -p mudd_prod > mudd_prod_2020-05-11.sql
gzip mudd_prod_2020-05-11.sql
exit
scp deploy@lib-mudd-prod1:mudd_prod_2020-05-11.sql.gz .
gunzip mudd_prod_2020-05-11.sql.gz
vi mudd_prod_2020-05-11.sql #remove @@GLOBAL.GTID_EXECUTED line
Locally - Change your database.yml dev name to match the server you are targeting mudd_prod
& mudd_prod user. This saves having to modify the postgres dump to match the new database.
mysql -u root mudd_prod < mudd_prod_2020-05-11.sql
pgloader mysql://root@localhost/mudd_prod postgresql://mudd_prod@localhost/mudd_prod
psql postgres
alter database mudd_prod set search_path to mudd_prod, public;
update your database.yml to have the new postgres connection information and check that the dev environment is still working
rails s
run the tests
rspec
dump the postgres database
pg_dump -U mudd_prod mudd_prod > mudd_prod.dump
gzip mudd_prod.dump
Update princeton_ansible to point to the postgres database run the playbook
deploy the new postgres code to production
cap production deploy
scp the dump file to the server
scp mudd_prod.dump.gz deploy@lib-mudd-prod1:~
Stop nginx on server as pulsys
ssh pulsys@lib-postgres3
sudo service nginx stop
Log into the postgres server ``` ansible-vault view group_vars/all/vault.yml # look for postgres password ssh pulsys@lib-postgres3
psql -U postgresadmin DROP DATABASE muddprod; Create DATABASE muddprod; ```
On the server import the database as deploy
sudo su - deploy
cd ~
gunzip mudd_prod.dump.gz
more app_configs/mudd-dbs
psql -U mudd_prod -d mudd_prod -h lib-postgres3.princeton.edu -f /home/deploy/mudd_prod.dump
start nginx as pulsys
exit
sudo service nginx start
referenced
by Shaun Ellis at 2020-05-08 19:10:41.merged
by Shaun Ellis at 2020-05-08 19:10:41.closed
by Shaun Ellis at 2020-05-08 19:10:41.head_ref_deleted
by Shaun Ellis at 2020-05-08 19:10:43.closed
by Christina Chortaria at 2020-05-08 20:35:49.Coverage increased (+0.03%) to 96.568% when pulling dd1e9471b06c52d8f51018f3d26c9e30aebcc566 on 1569-numismatics-search into 3697f4692cdf1d4b2f00c6a62e5b918bbeacee12 on master.
deployed
by Trey Pendragon at 2020-05-08 17:02:45.head_ref_force_pushed
by Eliot Jordan at 2020-05-08 17:15:15.review_requested
by Christina Chortaria at 2020-05-08 18:17:07.review_requested
by Eliot Jordan at 2020-05-08 20:14:05.referenced
by Christina Chortaria at 2020-05-08 20:35:49.merged
by Christina Chortaria at 2020-05-08 20:35:49.closed
by Christina Chortaria at 2020-05-08 20:35:49.Coverage remained the same at 96.568% when pulling 91ed11562b0e8422222740ff5fce5bf7e833d3fe on 1945-update-rails-5.2 into b307bafa8de7deb448e2e46e095b6a803755350f on master.
@carolyncole this PR is pointing to https://github.com/pulibrary/requests/pull/538 I asked you to review both. We can check them on Monday if you have time. not urgent
head_ref_force_pushed
by Christina Chortaria at 2020-05-08 21:50:47.ready_for_review
by Christina Chortaria at 2020-05-08 22:12:14.review_requested
by Christina Chortaria at 2020-05-08 22:12:21.mentioned
by None at 2020-05-08 22:15:12.subscribed
by None at 2020-05-08 22:15:12.head_ref_force_pushed
by None at 2020-05-08 11:58:24.referenced
by Kevin Reiss at 2020-05-08 13:03:30.merged
by Kevin Reiss at 2020-05-08 13:03:30.closed
by Kevin Reiss at 2020-05-08 13:03:30.head_ref_deleted
by Kevin Reiss at 2020-05-08 13:03:35.closed
by Francis Kayiwa at 2020-05-08 14:44:42.reopened
by Francis Kayiwa at 2020-05-08 14:44:48.closed
by Francis Kayiwa at 2020-05-08 14:45:26.referenced
by Francis Kayiwa at 2020-05-08 14:45:26.merged
by Francis Kayiwa at 2020-05-08 14:45:26.closed
by Francis Kayiwa at 2020-05-08 14:45:26.head_ref_deleted
by Francis Kayiwa at 2020-05-08 14:45:32.referenced
by Kevin Reiss at 2020-05-08 14:57:42.merged
by Kevin Reiss at 2020-05-08 14:57:42.closed
by Kevin Reiss at 2020-05-08 14:57:42.@hackmastera it seems odd to have your dependencies split You have a load of them in the playbook: https://github.com/pulibrary/princeton_ansible/blob/master/playbooks/figgy_staging.yml#L9-L25
@hackmastera and I had a conversation outside of git. The reason for this one being it the meta is it is required for the role to run properly.
mentioned
by None at 2020-05-08 14:42:22.subscribed
by None at 2020-05-08 14:42:22.mentioned
by None at 2020-05-08 15:10:57.subscribed
by None at 2020-05-08 15:10:57.referenced
by None at 2020-05-08 15:11:19.merged
by None at 2020-05-08 15:11:19.closed
by None at 2020-05-08 15:11:19.head_ref_deleted
by None at 2020-05-08 15:11:22.head_ref_force_pushed
by Francis Kayiwa at 2020-05-07 23:31:18.head_ref_force_pushed
by Francis Kayiwa at 2020-05-08 14:39:14.ready_for_review
by Francis Kayiwa at 2020-05-08 19:09:49.review_requested
by Francis Kayiwa at 2020-05-08 19:10:02.head_ref_force_pushed
by Francis Kayiwa at 2020-05-08 19:56:54.referenced
by Francis Kayiwa at 2020-05-08 20:55:29.merged
by Francis Kayiwa at 2020-05-08 20:55:29.closed
by Francis Kayiwa at 2020-05-08 20:55:29.head_ref_deleted
by Francis Kayiwa at 2020-05-08 20:55:32.head_ref_force_pushed
by Francis Kayiwa at 2020-05-08 20:56:55.@carolyncole
ready_for_review
by Christina Chortaria at 2020-05-08 22:12:57.review_requested
by Christina Chortaria at 2020-05-08 22:13:04.mentioned
by None at 2020-05-08 22:15:28.subscribed
by None at 2020-05-08 22:15:28.


TOP STORIES
{{article.subtitle}}
by {{article.author}}
CATEGORIES
LATEST NEWS
{{article.publishedDate}}


In this guide you will be able to visualize high school graduation rates by high school, student achievement level before high school, student race/ethnicity, on-track status after ninth-grade.
The College-Going Pathways series is a set of guides, code, and sample data about policy-relevant college-going topics. Browse this and other guides in the series for ideas about ways to investigate student pathways through high school and college. Each guide includes several analyses in the form of charts together with Stata analysis and graphing code to generate each chart.
Once you’ve identified analyses that you want to try to replicate or modify, click the “Download” buttons to download Stata code and sample data. You can make changes to the charts using the code and sample data, or modify the code to work with your own data. If you’re familiar with Github, you can click “Go to Repository” and clone the entire College-Going Pathways repository to your own computer.
The data visualizations in the College-Going Pathways series use a synthetically generated college-going analysis sample data file which has one record per student. Each high school student is assigned to a ninth-grade cohort, and each student record includes demographic and program participation information, annual GPA and on-track status, high school graduation outcomes, and college enrollment information. The Connect guide (coming soon) will provide guidance and example code which will help you build a college-going analysis file using data from your own school system.
High school graduation is a critical step to higher education. Understanding trends and variations in high school completion rates across schools and student subgroups is essential. These analyses reveal the extent to which high schools may differentially influence student trajectories towards high school completion. After identifying these high schools, you may conduct deeper analyses on your own to explore what drives these outcomes.
One of the most important decisions in running each analysis is defining the sample. Each analysis corresponds to a different part of the education pipeline and as a result requires different cohorts of students.
If you are using the synthetic data we have provided, the sample restrictions have been predefined and are included below. If you run this code using your own agency data, change the sample restrictions based on your data. Note that you will have to run these sample restrictions at the beginning of your do file so they will feed into the rest of your code.
// Sample Restrictions
// Agency name
global agency_name "Agency"
// Ninth grade cohorts you can observe persisting to the second year of college
global chrt_ninth_begin_persist_yr2 = 2004
global chrt_ninth_end_persist_yr2 = 2006
// Ninth grade cohorts you can observe graduating high school on time
global chrt_ninth_begin_grad = 2004
global chrt_ninth_end_grad = 2006
// Ninth grade cohorts you can observe graduating high school one year late
global chrt_ninth_begin_grad_late = 2004
global chrt_ninth_end_grad_late = 2006
// High school graduation cohorts you can observe enrolling in college the fall after graduation
global chrt_grad_begin = 2007
global chrt_grad_end = 2009
// High school graduation cohorts you can observe enrolling in college two years after hs graduation
global chrt_grad_begin_delayed = 2007
global chrt_grad_end_delayed = 2009
Based on the sample data, you will have three cohorts (sometimes only two) for analysis. If you are using your own agency data, you may decide to aggregate results for more or fewer cohorts to report your results. This decision depends on 1) how much historical data you have available and 2) what balance to strike between reliability and averaging away information on recent trends. We suggest you average results for the last three cohorts to take advantage of larger sample sizes and improve reliability. However, if you have data for more than three cohorts, you may decide to not average data out for fear of losing information about trends and recent changes in your agency.
This guide is an open-source document hosted on Github and generated using the Stata Webdoc package. We welcome feedback, corrections, additions, and updates. Please visit the OpenSDP college-going pathways repository to read our contributor guidelines.
Purpose: This analysis explores variation in high school completion rates across high schools in the system for both on-time and late high school graduates.
Required Analysis File Variables:
sid
chrt_ninth
hs_diploma
ontime_grad
late_grad
first_hs_code
first_hs_name
Analysis-Specific Sample Restrictions: Keep students in ninth grade cohorts you can observe graduating high school one year late
Ask Yourself
Does the ordering of high school completion rates coincide with beliefs key stakeholders have about these high schools?
Which high schools have the highest and lowest completion rates? Do you know why?
Analytic Technique: Calculate the proportion of students who complete high school by school.
// High School Completion Rates By School
// Step 1: Load the college-going analysis file into Stata
use "$data/college_going_analysis", clear
// Step 2: Keep students in ninth grade cohorts you can observe graduating high school one year late
local chrt_ninth_begin = ${chrt_ninth_begin_grad_late}
local chrt_ninth_end = ${chrt_ninth_end_grad_late}
keep if (chrt_ninth >= `chrt_ninth_begin' & chrt_ninth <= `chrt_ninth_end')
// Step 3: Obtain the agency-level high school graduation rates.
preserve
collapse (mean) ontime_grad late_grad (count) N = sid
tempfile agency_level
save `agency_level'
restore
// Step 4: Obtain the school-level high school graduation rates and append the agency average
collapse (mean) ontime_grad late_grad (count) N = sid, by(first_hs_name first_hs_code)
append using `agency_level'
// Step 5: Provide a hs name label for the appended agency average and shorten hs name
replace first_hs_code = 0 if first_hs_code == .
replace first_hs_name = "${agency_name} AVERAGE" if mi(first_hs_name)
replace first_hs_name = subinstr(first_hs_name, " High School", "", .)
// Step 6: Multiply the average of each outcome by 100 for graphical representation of the rates
foreach var of varlist ontime_grad late_grad {
replace `var' = `var' * 100
format `var' %9.1f
}
// Step 7: Prepare to graph the results
// Generate a cohort label to be used in the footnote for the graph
local temp_begin = `chrt_ninth_begin'-1
local temp_end = `chrt_ninth_end'-1
if `chrt_ninth_begin'==`chrt_ninth_end' {
local chrt_label "`temp_begin'-`chrt_ninth_begin'"
}
else {
local chrt_label "`temp_begin'-`chrt_ninth_begin' through `temp_end'-`chrt_ninth_end'"
}
// Step 8: Graph the results
#delimit ;
graph bar (sum) ontime_grad late_grad, stack over(first_hs_name, label(angle(40)
labsize(small)) gap(20) sort(ontime_grad))
blabel(bar, position(inside) color(black) size(small) format(%8.0f))
bar(1, fcolor(dkorange) fintensity(70) lcolor(black))
bar(2, fcolor(navy) fintensity(70) lcolor(black))
legend(region(lcolor(white)) symxsize(3) symysize(2) rows(2) order(2 1) size(vsmall)
position(11) label(1 "On-Time High School Graduate") label(2 "Graduate in 4+ Yrs."))
title("High School Graduation Rates by High School")
ytitle("Percent of Ninth Graders") yscale(range(0(20)100)) ylabel(0(20)100, nogrid)
graphregion(color(white) fcolor(white) lcolor(white))
plotregion(color(white) fcolor(white) lcolor(white))
note(" " "Sample: `chrt_label' ${agency_name} first-time ninth graders. Data from ${agency_name} administrative records." , size(vsmall));
#delimit cr
graph export "figures/C1_HS_Grad_by_HS.png", replace width(1600) height(1200)
Purpose: This analysis examines the relationship between academic achievement at high school entry and high school completion rates. This analysis is useful to identify high schools that beat the odds. High schools with similar incoming student achievement profiles but different high school graduation rates.
Required Analysis File Variables:
sid
chrt_ninth
test_math_8_std
hs_diploma
first_hs_code
first_hs_name
Analysis-Specific Sample Restrictions:
Ask Yourself
What might explain differences in high school graduation rates for high schools with similar incoming achievement? What might explain differences in incoming achievement for high schools with similar graduation rates?
Possible Next Steps or Action Plans: If substantial variation exists after controlling for average student achievement at high school entry, think about how to share this information across schools. To explore mechanisms that drive school-level differences in high school completion rates, replicate this analysis where the x-axis is a middle school at-risk index (e.g. an index that accounts for whether students failed a core class, were chronically absent, and other information predictive of student achievement in high school) in place of 8th grade test scores.
Analytic Technique: Bivariate scatterplot of school-level average student test scores and high school completion rates.
// High School Completion Rates by Average 8th Grade Achievement
// Step 1: Load the college-going analysis file into Stata.
use "$data/college_going_analysis", clear
// Step 2: Keep students in ninth grade cohorts you can observe graduating high school AND have non-missing eighth grade math scores.
local chrt_ninth_begin = ${chrt_ninth_begin_grad}
local chrt_ninth_end = ${chrt_ninth_end_grad}
keep if (chrt_ninth >= `chrt_ninth_begin' & chrt_ninth <= `chrt_ninth_end') & !mi(test_math_8_std)
// Step 3: Obtain agency-level high school completion rate and prior achievement score along with the position of their labels.
summ ontime_grad
local agency_mean_grad = `r(mean)'*100
local agency_mean_grad_label = `agency_mean_grad' + 3
summ test_math_8_std
local agency_mean_test = `r(mean)'
local agency_mean_test_label = `agency_mean_test' + 0.15
// Step 4: Obtain school-level high school completion and prior achievement rates
collapse (mean) test_math_8_std ontime_grad (count) N = sid, by(first_hs_code first_hs_name)
drop if N < 20
// Step 5: Multiply the high school completion rate by 100 for graphical representation of the rates,
replace ontime_grad = round((ontime_grad * 100), .1)
// Step 6: Shorten high school names and create a legend label for the graph
sort first_hs_name
replace first_hs_name = subinstr(first_hs_name, " High School", "", .)
gen hs_code_label = _n
levelsof first_hs_name, local(hs_names)
local count = 1
local legend_labels ""
foreach hs of local hs_names {
local legend_labels `"`legend_labels' `count' = `hs'"' `" "'
local ++count
}
// Step 7: Prepare to graph the results
// Generate a cohort label to be used in the footnote for the graph
local temp_begin = `chrt_ninth_begin'-1
local temp_end = `chrt_ninth_end'-1
if `chrt_ninth_begin'==`chrt_ninth_end' {
local chrt_label "`temp_begin'-`chrt_ninth_begin'"
}
else {
local chrt_label "`temp_begin'-`chrt_ninth_begin' through `temp_end'-`chrt_ninth_end'"
}
// Step 8: Graph the results
#delimit ;
twoway (scatter ontime_grad test_math_8_std, mlabel(hs_code_label) mlabsize(vsmall)
mlabposition(12) mlabcolor(dknavy) mstyle(x) msize(small) mcolor(dknavy)),
title("On-Time High School Graduation")
subtitle("By Student Achievement Profile Upon High School Entry")
xtitle("Average 8th Grade Math Standardized Score", linegap(0.3))
ytitle("Percent of Ninth Graders")
xscale(range(-0.8(0.2)1)) xlabel(-0.8(0.2)1)
yscale(range(0(20)100)) ylabel(0(20)100, nogrid)
legend(on order(3) col(1) label(3 `"`legend_labels'"')
region(color(none)) size(vsmall) position(2) ring(1) linegap(.75))
yline(`agency_mean_grad', lpattern(dash) lcolor(dknavy) lwidth(vvthin))
xline(`agency_mean_test', lpattern(dash) lcolor(dkorange) lwidth(vvthin))
text(`agency_mean_grad_label' .8 "${agency_name} Average Graduation Rate", size(2.0) color(dknavy))
text(2 `agency_mean_test_label' "${agency_name} Average" "Test Score", size(2.0) color(dkorange))
text(99 -.5 "Below average math scores &" "above average graduation rates",
size(vsmall) justification(left))
text(99 0.8 "Above average math scores &" "above average graduation rates",
size(vsmall) justification(right))
text(2 -0.5 "Below average math scores &" "below average graduation rates",
size(vsmall) justification(left))
text(2 0.8 "Above average math scores &" "below average graduation rates",
size(vsmall) justification(right))
graphregion(color(white) fcolor(white) lcolor(white))
plotregion(color(white) fcolor(white) lcolor(white))
note("Sample: `chrt_label' ${agency_name} first-time ninth graders with eighth grade math test scores." "All data from ${agency_name} administrative records.", size(vsmall));
#delimit cr
graph export "figures/C2_HS_Grad_by_Avg_Eighth.png", replace width(1600) height(1200)
Purpose: This analysis examines variation in completion rates for high schools among students with 8th grade test scores in the same quartile. The analysis is useful to explore high school completion rates across schools with students in the same quartile or range of achievement. Each high school is repeated as a blue bar in each quartile.
Required Analysis File Variables:
sid
chrt_ninth
test_math_8_std
hs_diploma
first_hs_code
first_hs_name
Analysis-Specific Sample Restrictions:
Ask Yourself
Possible Next Steps or Action Plans: Highlight comparison schools to show variation across quartiles and explore reasons why students at different schools, but with similar academic profiles at high school entry, are more or less likely to graduate.
Analytic Technique: Calculate the proportion of students, by high school, who complete high school and an 8th grade test score quartile for each.
// High School Completion Rates by 8th Grade Achievement Quartiles
// Step 1: Load the college-going analysis file into Stata.
use "$data/college_going_analysis", clear
// Step 2: Keep students in ninth grade cohorts you can observe graduating high school AND have non-missing eighth grade math scores.
local chrt_ninth_begin = ${chrt_ninth_begin_grad}
local chrt_ninth_end = ${chrt_ninth_end_grad}
keep if (chrt_ninth >= `chrt_ninth_begin' & chrt_ninth <= `chrt_ninth_end') & !mi(test_math_8)
// Step 3: Obtain the overall agency-level high school graduation rate along with the position of its label.
summ ontime_grad
local agency_mean = `r(mean)'*100
local agency_mean_label = `agency_mean'+3
// Step 4: Obtain the agency-level high school graduation rates by test score quartile.
preserve
collapse (mean) ontime_grad (count) N = sid, by(qrt_8_math)
tempfile agency_level
save `agency_level'
restore
// Step 5: Obtain school-level high school graduation rates by test score quartile and append the agency-level graduation rates by quartile
collapse (mean) ontime_grad (count) N = sid, by(first_hs_code first_hs_name qrt_8_math)
append using `agency_level'
// Step 6: Shorten high school names and drop any high schools with fewer than 20 students
replace first_hs_code = 0 if first_hs_code == .
replace first_hs_name = "${agency_name} Average" if mi(first_hs_name)
replace first_hs_name = subinstr(first_hs_name, " High School", "", .)
drop if N < 20
// Step 7: Multiply the high school completion rate by 100 for graphical representation of the rates
replace ontime_grad = round((ontime_grad * 100), .1)
// Step 8: Create a variable to sort schools within each test score quartile in ascending order
sort qrt_8_math ontime_grad
gen rank = _n
// Step 9: Prepare to graph the results
// Generate a cohort label to be used in the footnote for the graph
local temp_begin = `chrt_ninth_begin'-1
local temp_end = `chrt_ninth_end'-1
if `chrt_ninth_begin'==`chrt_ninth_end' {
local chrt_label "`temp_begin'-`chrt_ninth_begin'"
}
else {
local chrt_label "`temp_begin'-`chrt_ninth_begin' through `temp_end'-`chrt_ninth_end'"
}
// Step 10: Graph the results
#delimit ;
graph bar ontime_grad, over(first_hs_name, sort(rank) gap(0) label(angle(70) labsize(vsmall)))
over(qrt_8_math, relabel(1 "Bottom Quartile" 2 "2nd Quartile" 3 "3rd Quartile" 4 "Top Quartile") gap(400))
bar(1, fcolor(dknavy) finten(70) lcolor(dknavy) lwidth(thin))
blabel(bar, format(%8.0f) size(1.5))
yscale(range(0(20)100)) ylabel(0(20)100, nogrid) legend(off)
title("On-Time High School Graduation Rates")
subtitle("By Prior Student Achievement", size(msmall))
ytitle("Percent of Ninth Graders")
yline(`agency_mean', lpattern(dash) lwidth(vvthin) lcolor(dknavy))
text(`agency_mean_label' 5 "${agency_name} Average", size(vsmall))
graphregion(color(white) fcolor(white) lcolor(white))
plotregion(color(white) fcolor(white) lcolor(white))
note(" " "Sample: `chrt_label' ${agency_name} first-time ninth graders with eighth grade math test scores." "All data from ${agency_name} administrative records.", size(vsmall));
#delimit cr
graph export "figures/C3_HS_Grad_by_Eighth_Qrt.png", replace width(1600) height(1200)
Purpose: This analysis displays an overall graduation gap by race, and examines the extent to which this gap is explained by average differences in academic achievement between racial sub-groups at high school entry. The analysis is useful to diagnose whether racial gaps in high school result from persistent academic achievement gaps that emerge in early grades, or if other factors unique to the high school experience drive high school completion rate differences by race.
Required Analysis File Variables:
sid
chrt_ninth
test_math_8_std
hs_diploma
first_hs_code
first_hs_name
Analysis-Specific Sample Restrictions:
Ask Yourself
Possible Next Steps or Action Plans: Repeat analyses for only students that qualify for free or reduced price lunch (FRPL) to explore if racial gaps are better explained by disparities in prior academic achievement and family socioeconomic status.
Analytic Technique: Calculate the proportion of students who complete high school by race/ethnicity overall, and by race/ethnicity and 8th grade test score quartile.
// Racial Gaps in Completion Overall and by 8th Grade Achievement Quartiles
// Step 1: Load the college-going analysis file into Stata
use "$data/college_going_analysis", clear
// Step 2: Keep students in ninth grade cohorts you can observe graduating high school AND have non-missing eighth grade math scores
local chrt_ninth_begin = ${chrt_ninth_begin_grad}
local chrt_ninth_end = ${chrt_ninth_end_grad}
keep if (chrt_ninth >= `chrt_ninth_begin' & chrt_ninth <= `chrt_ninth_end') & !mi(test_math_8)
// Step 3: Obtain the average on-time high school completion rate by race/ethnicity; you will restore in step 8
preserve
collapse (mean) ontime_grad (count) N=sid, by(race_ethnicity)
// Step 4: Multiply the high school completion rate by 100 for graphical representation of the rates
replace ontime_grad = (ontime_grad * 100)
// Step 5: Reshape the data wide so that each race is associated with the outcome variable
gen id = _n
reshape wide ontime_grad, i(id) j(race_ethnicity)
// Step 6: Prepare to graph the results
// Generate a cohort label to be used in the footnote for the graph
local temp_begin = `chrt_ninth_begin'-1
local temp_end = `chrt_ninth_end'-1
if `chrt_ninth_begin'==`chrt_ninth_end' {
local chrt_label "`temp_begin'-`chrt_ninth_begin'"
}
else {
local chrt_label "`temp_begin'-`chrt_ninth_begin' through `temp_end'-`chrt_ninth_end'"
}
// Step 7: Graph the results (1/2)
#delimit ;
graph bar ontime_grad3 ontime_grad1 ontime_grad5 ontime_grad2,
bargap(25) outergap(100)
bar(1, fcolor(forest_green*.7) lcolor(forest_green*.7))
bar(2, fcolor(dknavy*.7) lcolor(dknavy*.7))
bar(3, fcolor(orange*.7) lcolor(orange*.7))
bar(4, fcolor(lavender*.85) lcolor(lavender*.85))
blabel(bar, size(small) format(%8.0f))
text(-4 22 "Hispanic", size(small))
text(-4 40 "African American", size(small))
text(-4 59 "White", size(small))
text(-4 77 "Asian American", size(small))
title("On-Time High School Graduation Rates")
subtitle("by Race")
ytitle("Percent of Ninth Graders")
yscale(range(0(20)100))
ylabel(0(20)100, nogrid)
legend(off)
graphregion(color(white) fcolor(white) lcolor(white))
plotregion(color(white) fcolor(white) lcolor(white))
note(" " " " "Sample: `chrt_label' ${agency_name} first-time ninth graders." "All data from ${agency_name} administrative records.", size(vsmall));
#delimit cr
graph export "figures/C4a_HS_Grad_by_Race.png", replace width(1600) height(1200)
// Step 8: Restore the data and repeat steps 3-6 to obtain completion rates by race/ethnicity and eighth grade test score quartiles
restore
collapse (mean) ontime_grad (count) N=sid, by(race_ethnicity qrt_8_math)
replace ontime_grad = (ontime_grad * 100)
reshape wide ontime_grad, i(qrt_8_math N) j(race_ethnicity)
// Step 9: Graph the results (2/2)
#delimit ;
graph bar ontime_grad3 ontime_grad1 ontime_grad5 ontime_grad2, over(qrt_8_math,
relabel(1 "Bottom Quartile" 2 "2nd Quartile" 3 "3rd Quartile" 4 "Top Quartile") label(labsize(small)))
bar(1, fcolor(forest_green*.7) lcolor(forest_green*.7)) bar(2, fcolor(dknavy*.7) lcolor(dknavy*.7))
bar(3, fcolor(orange*.7) lcolor(orange*.7)) bar(4, fcolor(lavender*.85) lcolor(lavender*.85))
blabel(bar, format(%8.0f))
title("On-Time High School Graduation Rates")
subtitle("By Race and Prior Achievement")
b1title("8th Grade Math Score Test Quartile")
ytitle("Percent of Ninth Graders") yscale(range(0(20)100)) ylabel(0(20)100, nogrid)
legend(order(1 2 3 4) row(1) label(1 "Hispanic")
label(2 "African American") label(3 "White") label(4 "Asian American") size(vsmall)
symxsize(7) position(inside) ring(1) region(lstyle(none)
lcolor(none) color(none)))
graphregion(color(white) fcolor(white) lcolor(white))
plotregion(color(white) fcolor(white) lcolor(white))
note("Sample: `chrt_label' ${agency_name} first-time ninth graders." "All data from ${agency_name} administrative records.", size(vsmall));
#delimit cr
graph export "figures/C4b_HS_Grad_by_Race_by_Eighth_Qrt.png", replace width(1600) height(1200)
Purpose: This analysis explores how strongly student performance in ninth grade predicts high school graduation three years later. Building upon our analysis of the relationship between student performance in ninth and tenth grade, the analysis assesses the utility of using course-level performance data early in students’ high school careers to assess risk of non-completion, and target students in need of academic and/or socio-emotional support.
Required Analysis File Variables:
sid
chrt_ninth
ontrack_grad_hs_sample*
ontrack_endyr1*
cum_gpa_yr1*
status_after_yr4*
Analysis-Specific Sample Restrictions: - Keep students in ninth grade cohorts you can observe graduating high school AND are part of the on-track sample (attended the first semester of ninth grade and never transferred into or out of the system).
Ask Yourself - How does on-track status at the end of ninth grade relate to high school completion status at the end of four years?
Possible Next Steps or Action Plans: Repeat analyses for only students that qualify for free or reduced price lunch (FRPL) to explore whether racial gaps are better explained by disparities in prior academic achievement and family socioeconomic status.
Analytic Technique: Calculate the proportion of students who graduate high school within four years, dropout, remain enrolled in high school for a fifth year, etc. based on on-track status upon completion of ninth grade.
if 0 {
// Enrollment Outcome in Year Four By On-Track Status At the End of Ninth Grade
// Step 1: Load the college-going analysis file into Stata
use "$data/college_going_analysis", clear
// Step 2: Keep students in ninth grade cohorts you can observe graduating high school AND are part of the on-track sample (attended the first semester of ninth grade and never transferred into or out of the system)
local chrt_ninth_begin = ${chrt_ninth_begin_grad}
local chrt_ninth_end = ${chrt_ninth_end_grad}
keep if (chrt_ninth >= `chrt_ninth_begin' & chrt_ninth <= `chrt_ninth_end') & !mi(cum_gpa_yr1)
keep if ontrack_sample==1
// Step 3: Make sure that the on-track status after year 4 is not missing
label define status 1 "Graduated On-Time" 2 "Still Enrolled" 3 "Dropout" 4 "Disappear", replace
label values status_after_yr4 status
tab status_after_yr4, m
keep if !mi(status_after_yr4)
// Step 4: Keep only the variables of interest and generate graduation outcomes after year 4. Assign students as still enrolled if they have a graduation cohort but are not observed to be on-time graduates
keep status_after_yr4 ontrack_endyr1 chrt_grad chrt_ninth ontime_grad sid still_enrl dropout disappear cum_gpa_yr1
gen hs_grad = (status_after_yr4 == 1)
replace still_enrl = 1 if ontime_grad == 0 & !mi(chrt_grad)
// Step 5: Ensure that the graduation outcome variables after year 4 are now mutually exclusive for each student
assert hs_grad + still_enrl + dropout + disappear == 1
// Step 6: Generate on-track indicators that take into account students' GPA upon completion of their first year in high school.
label define ot 1 "Off-Track to Graduate" 2 "On-Track, GPA < 3.0" ///
3 "On-Track, GPA >= 3.0", replace
gen ontrack_endyr1_gpa = .
replace ontrack_endyr1_gpa = 1 if ontrack_endyr1 == 0
replace ontrack_endyr1_gpa = 2 if ontrack_endyr1 == 1 & cum_gpa_yr1 < 3 & !mi(cum_gpa_yr1)
replace ontrack_endyr1_gpa = 3 if ontrack_endyr1 == 1 & cum_gpa_yr1 >= 3 & !mi(cum_gpa_yr1)
label values ontrack_endyr1_gpa ot
// Step 7: Create average outcomes by on-track status at the end of ninth grade.
collapse (mean) hs_grad still_enrl dropout disappear (count) N=sid, by(ontrack_endyr1_gpa)
// Step 8: Format the outcome variables so they read as percentages in the graph
foreach var of varlist hs_grad still_enrl dropout disappear {
replace `var' = ( `var' * 100)
format `var' %9.0f
}
// Step 9: For students who dropout or disappear, convert their values to be negative for ease of visualization in the graph
foreach var in dropout disappear {
replace `var' = `var'*-1
}
// Step 10: Prepare to graph the results
// Generate a cohort label to be used in the footnote for the graph
local temp_end = `chrt_ninth_end'-1
if `chrt_ninth_begin'==`chrt_ninth_end' {
local chrt_label "`temp_begin'-`chrt_ninth_begin'"
}
else {
local chrt_label "`temp_begin'-`chrt_ninth_begin' through `temp_end'-`chrt_ninth_end'"
}
// Step 11: Graph the results
#delimit ;
graph bar dropout disappear still_enrl hs_grad, over(ontrack_endyr1, gap(100) label(labsize(2.5)))
stack blabel(bar, position(inside) color(black) format(%9.0f) size(2.1))
bar(1, fcolor(maroon*.8) lcolor(maroon*.85))
bar(2, fcolor(dkorange*.5) lcolor(dkorange*.65) lwidth(vvthin))
bar(3, fcolor(navy*.5) lcolor(navy*.65) lwidth(vvthin))
bar(4, fcolor(navy*.8) lcolor(navy*.95) lwidth(vvthin))
legend(col(1) order(4 3 1 2)
lab(1 "Drop Out")
lab(2 "Disappear" )
lab(3 "Still Enrolled")
lab(4 "Graduated")
size(2.3) symxsize(2) symysize(2) position(2) region(color(none)) title("Status After Year Four", size(2.5)))
title("Enrollment Status After Four Years in High School", size(large))
subtitle("By Course Credits and GPA after First Year of High School", size(medium))
ytitle("Percent of Students", size(small) margin(2 2 0 0))
yscale(range(-60(20)100))
ylabel(-60(20)100, nogrid labsize(small))
ylabel(-60 "60" -40 "40" -20 "20" 0 "0" 20 "20" 40 "40" 60 "60" 80 "80" 100 "100")
yline(0, lcolor(black) lwidth(vvthin))
text(-87 50 "Ninth Grade On-Track Status", size(small))
graphregion(color(white) fcolor(white) lcolor(white))
plotregion(color(white) fcolor(white) lcolor(white))
note(" " " " " " "Sample: `chrt_label' ${agency_name} first-time ninth graders. Students who transferred into or out of the agency"
"are excluded from the sample. All data from ${agency_name} administrative records." , size(vsmall));
#delimit cr
graph export "figures/C5_Yr4_Status_by_OnTrack_Ninth.png", replace width(1600) height(1200)
}


TOTAL EARNINGS
get(T_PAYMENTS); $total_earnings_tm = $db->where('date',"$month/$year")->get(T_PAYMENTS); $total_sales = count($total_earnings); for($i=1; $i < 13; $i++) { $pro_sales_static = $db->where('date',"$i/$year")->getValue(T_PAYMENTS, 'count(*)'); $json_static_dump[] = array( 'month' => $pt->months[$i], 'pro_sales' => $pro_sales_static ); } $json_static_dump = json_encode($json_static_dump); foreach ($total_earnings as $amount) { $total_earnings_sum += $amount->amount; } foreach ($total_earnings_tm as $amount) { $total_earnings_tms += $amount->amount; } ?>


|
CUTLASS
CUDA Templates for Linear Algebra Subroutines and Solvers
|
Mapping function for pitch-linear memory.
#include <pitch_linear.h>
Public Types | |
| using | Index = int32_t |
| Index type used for coordinates. More... | |
| using | LongIndex = int64_t |
| Long index type used for offsets. More... | |
| using | TensorCoord = PitchLinearCoord |
| Logical coordinate. More... | |
| using | Stride = Coord< kStrideRank, Index > |
| Stride vector. More... | |
Public Member Functions | |
| CUTLASS_HOST_DEVICE | PitchLinear (Index ldm=0) |
| Constructor. More... | |
| CUTLASS_HOST_DEVICE | PitchLinear (Stride _stride) |
| Constructor. More... | |
| CUTLASS_HOST_DEVICE LongIndex | operator() (TensorCoord const &coord) const |
| CUTLASS_HOST_DEVICE TensorCoord | inverse (LongIndex index) const |
| Returns the logical coordinate given an offset. More... | |
| CUTLASS_HOST_DEVICE Stride | stride () const |
| Returns the stride of the layout. More... | |
| CUTLASS_HOST_DEVICE Stride & | stride () |
| Returns the stride of the layout. More... | |
| CUTLASS_HOST_DEVICE Index | stride (int rank) const |
| Returns the stride of the layout. More... | |
| CUTLASS_HOST_DEVICE Index & | stride (int rank) |
| Returns the stride of the layout. More... | |
| CUTLASS_HOST_DEVICE LongIndex | capacity (TensorCoord const &extent) const |
| Compute the number of contiguous elements needed to store a tensor with the given size. More... | |
Static Public Member Functions | |
| static CUTLASS_HOST_DEVICE PitchLinear | packed (TensorCoord const &extent) |
| Helper returns a layout to a tightly packed tensor. More... | |
Static Public Attributes | |
| static int const | kRank = 2 |
| Logical rank of tensor. More... | |
| static int const | kStrideRank = 1 |
| Rank of stride vector. More... | |
| using cutlass::layout::PitchLinear::Index = int32_t |
| using cutlass::layout::PitchLinear::LongIndex = int64_t |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
Returns the offset of a coordinate in linear memory. Assumes coordinate has convention (contiguous, strided)
|
inlinestatic |
|
inline |
|
inline |
|
inline |
|
inline |
|
static |
|
static |


log(xbt) - xbt_aerr = log(xb) + (log(xgpot/xg) - .5*(.035*empn/(.01*pceng*ceng) + .035*empn(-1)/(.01*pceng(-1)*ceng(-1)))*log(empt/emp))/ (1 - .5*(.035*empn/(.01*pceng*ceng) + .035*empn(-1)/(.01*pceng(-1)*ceng(-1))))
log(xgpot) - xgpot_aerr = (y_xgpot(1)*(log(leppot) + log(qlww) + log(lqualt)) + y_xgpot(2)*log(ks) + y_xgpot(3)*log(veoa) + log(mfpt))/(1 - y_xgpot(4))
hgx - hgx_aerr = (.7*(hlept + hqlww + 400*d(log(lqualt))) + .265*hks + .035*400*d(log(veoa)) + hmfpt)/.965
hxbt - hxbt_aerr = (hgx - .5*(.035*empn/(.01*pceng*ceng) + .035*empn(-1)/(.01*pceng(-1)*ceng(-1)))*400*d(log(empt)))/ (1 - .5*(.035*empn/(.01*pceng*ceng) + .035*empn(-1)/(.01*pceng(-1)*ceng(-1))))
log(xbt) - xbt_aerr = y_xbt(1)*(log(leppot) + log(qlww) + log(lqualt)) + y_xbt(2)*log(ks) + log(mfpt) + log(xbtr)
hxbt - hxbt_aerr = .725*(hlept + hqlww + 400*d(log(lqualt))) + .275*hks + hmfpt + hxbtr
The role of energy as a factor of production was eliminated and thus the distinction between XBT and XGPOT, as well as HXBT and HGX, in STDVER became unnecessary.
The XBT equation in the new version replaces both XBT and XGPOT equations in the old version.
The HXBT equation in the new version replaces both HXBT and HGX equations in the old version.
Error terms XBTR and HXBTR were added to equations of XBT and HXBT, respectively.
The new version of FRB/US uses a new source of data for capital services, KS, and trend labor quality, LQUALT. The model now relies on the estimates of Fernald’s data sources (the trend of labor quality is computed by applying the HP filter to the original series with a λ coefficient of 6400.


Mercy-s Pizzeria is a company that delivers
more than type of pizzas
you would like to order.
We make delivery within the required time and Location.
Book now +254-708-434-156 or mail at:
Location
Huruma plazza Restaurant fourth floor
Copyright (c) 2020 Aoko Mercyline


Smart Lights
Lights & Groups
Scenes
Automation
Party
Settings
Account
Speech
RFID
Network Devices
New RFID-Tag available.

YES
NO
Do you want to remove the device "{{sharedScope.state.devices[sharedScope.devices.selectedDeviceId].name}}"?
YES
NO


| Name | Description |
| Conditional Branching |
| PAPI_BR_CN | Conditional branch instructions
|
|
| PAPI_BR_INS | Branch instructions
|
|
| PAPI_BR_MSP | Conditional branch instructions mispredicted
|
|
| PAPI_BR_NTK | Conditional branch instructions not taken
|
|
| PAPI_BR_PRC | Conditional branch instructions correctly predicted
|
|
| PAPI_BR_TKN | Conditional branch instructions taken
|
|
| PAPI_BR_UCN | Unconditional branch instructions
|
|
| PAPI_BRU_IDL | Cycles branch units are idle
|
|
| PAPI_BTAC_M | Branch target address cache misses
|
| Cache Requests: |
| PAPI_CA_CLN | Requests for exclusive access to clean cache line
|
|
| PAPI_CA_INV | Requests for cache line invalidation
|
|
| PAPI_CA_ITV | Requests for cache line intervention
|
|
| PAPI_CA_SHR | Requests for exclusive access to shared cache line
|
|
| PAPI_CA_SNP | Requests for a snoop
|
| Conditional Store: |
| PAPI_CSR_FAL | Failed store conditional instructions
|
|
| PAPI_CSR_SUC | Successful store conditional instructions
|
|
| PAPI_CSR_TOT | Total store conditional instructions
|
| Floating Point Operations: |
| PAPI_FAD_INS | Floating point add instructions
|
|
| PAPI_FDV_INS | Floating point divide instructions
|
|
| PAPI_FMA_INS | FMA instructions completed
|
|
| PAPI_FML_INS | Floating point multiply instructions
|
|
| PAPI_FNV_INS | Floating point inverse instructions
|
|
| PAPI_FP_INS | Floating point instructions
|
|
| PAPI_FP_OPS | Floating point operations
|
|
| PAPI_FP_STAL | Cycles the FP unit
|
|
| PAPI_FPU_IDL | Cycles floating point units are idle
|
|
| PAPI_FSQ_INS | Floating point square root instructions
|
| Instruction Counting: |
| PAPI_FUL_CCY | Cycles with maximum instructions completed
|
|
| PAPI_FUL_ICY | Cycles with maximum instruction issue
|
|
| PAPI_FXU_IDL | Cycles integer units are idle
|
|
| PAPI_HW_INT | Hardware interrupts
|
|
| PAPI_INT_INS | Integer instructions
|
|
| PAPI_TOT_CYC | Total cycles
|
|
| PAPI_TOT_IIS | Instructions issued
|
|
| PAPI_TOT_INS | Instructions completed
|
|
| PAPI_VEC_INS | Vector/SIMD instructions
|
| Cache Access: |
| PAPI_L1_DCA | L1 data cache accesses
|
|
| PAPI_L1_DCH | L1 data cache hits
|
|
| PAPI_L1_DCM | L1 data cache misses
|
|
| PAPI_L1_DCR | L1 data cache reads
|
|
| PAPI_L1_DCW | L1 data cache writes
|
|
| PAPI_L1_ICA | L1 instruction cache accesses
|
|
| PAPI_L1_ICH | L1 instruction cache hits
|
|
| PAPI_L1_ICM | L1 instruction cache misses
|
|
| PAPI_L1_ICR | L1 instruction cache reads
|
|
| PAPI_L1_ICW | L1 instruction cache writes
|
|
| PAPI_L1_LDM | L1 load misses
|
|
| PAPI_L1_STM | L1 store misses
|
|
| PAPI_L1_TCA | L1 total cache accesses
|
|
| PAPI_L1_TCH | L1 total cache hits
|
|
| PAPI_L1_TCM | L1 total cache misses
|
|
| PAPI_L1_TCR | L1 total cache reads
|
|
| PAPI_L1_TCW | L1 total cache writes
|
|
| PAPI_L2_DCA | L2 data cache accesses
|
|
| PAPI_L2_DCH | L2 data cache hits
|
|
| PAPI_L2_DCM | L2 data cache misses
|
|
| PAPI_L2_DCR | L2 data cache reads
|
|
| PAPI_L2_DCW | L2 data cache writes
|
|
| PAPI_L2_ICA | L2 instruction cache accesses
|
|
| PAPI_L2_ICH | L2 instruction cache hits
|
|
| PAPI_L2_ICM | L2 instruction cache misses
|
|
| PAPI_L2_ICR | L2 instruction cache reads
|
|
| PAPI_L2_ICW | L2 instruction cache writes
|
|
| PAPI_L2_LDM | L2 load misses
|
|
| PAPI_L2_STM | L2 store misses
|
|
| PAPI_L2_TCA | L2 total cache accesses
|
|
| PAPI_L2_TCH | L2 total cache hits
|
|
| PAPI_L2_TCM | L2 total cache misses
|
|
| PAPI_L2_TCR | L2 total cache reads
|
|
| PAPI_L2_TCW | L2 total cache writes
|
|
| PAPI_L3_DCA | L3 data cache accesses
|
|
| PAPI_L3_DCH | L3 Data Cache Hits
|
|
| PAPI_L3_DCM | L3 data cache misses
|
|
| PAPI_L3_DCR | L3 data cache reads
|
|
| PAPI_L3_DCW | L3 data cache writes
|
|
| PAPI_L3_ICA | L3 instruction cache accesses
|
|
| PAPI_L3_ICH | L3 instruction cache hits
|
|
| PAPI_L3_ICM | L3 instruction cache misses
|
|
| PAPI_L3_ICR | L3 instruction cache reads
|
|
| PAPI_L3_ICW | L3 instruction cache writes
|
|
| PAPI_L3_LDM | L3 load misses
|
|
| PAPI_L3_STM | L3 store misses
|
|
| PAPI_L3_TCA | L3 total cache accesses
|
|
| PAPI_L3_TCH | L3 total cache hits
|
|
| PAPI_L3_TCM | L3 cache misses
|
|
| PAPI_L3_TCR | L3 total cache reads
|
|
| PAPI_L3_TCW | L3 total cache writes
|
| Data Access: |
| PAPI_LD_INS | Load instructions
|
|
| PAPI_LST_INS | Load/store instructions completed
|
|
| PAPI_LSU_IDL | Cycles load/store units are idle
|
|
| PAPI_MEM_RCY | Cycles Stalled Waiting for memory Reads
|
|
| PAPI_MEM_SCY | Cycles Stalled Waiting for memory accesses
|
|
| PAPI_MEM_WCY | Cycles Stalled Waiting for memory writes
|
|
| PAPI_PRF_DM | Data prefetch cache misses
|
|
| PAPI_RES_STL | Cycles stalled on any resource
|
|
| PAPI_SR_INS | Store instructions
|
|
| PAPI_STL_CCY | Cycles with no instructions completed
|
|
| PAPI_STL_ICY | Cycles with no instruction issue
|
|
| PAPI_SYC_INS | Synchronization instructions completed
|
| TLB Operations: |
| PAPI_TLB_DM | Data translation lookaside buffer misses
|
|
| PAPI_TLB_IM | Instruction translation lookaside buffer misses
|
|
| PAPI_TLB_SD | Translation lookaside buffer shootdowns
|
|
| PAPI_TLB_TL | Total translation lookaside buffer misses
|


Juneau 8.1.2 is a moderate release.
juneau-marshall
-
Support for read-only and write-only properties.
Bean.bpro()
Bean.bpwo()
- {@link oaj.annotation.Beanp#ro()}
- {@link oaj.annotation.Beanp#wo()}
BEAN_bpro
BEAN_bpwo
Builder.bpro(Map)
Builder.bpwo(Map)
-
New convenience methods:
ObjectMap.parse(CharSequence)
ObjectList.parse(CharSequence)
-
CharMarshalland StreamMarshall now have public constructors.
-
{@link oaj.annotation.Beanp @Beanp} replaces
BeanProperty @BeanProperty.
-
{@link oaj.annotation.Beanc @Beanc} replaces
BeanConstructor @BeanConstructor.
-
{@link oaj.http.remote.Remote @Remote} replaces
RemoteResource @RemoteResource.
-
Shortened names for {@link oaj.annotation.Bean#dictionary @Bean(dictionary)} and {@link oaj.BeanContext.Builder#beanDictionary(Class...)}.
juneau-rest-server
-
{@link oajr.annotation.Rest @Rest} replaces
RestResource @RestResource with shorter syntax.
-
New method
RestResponse.setHeaderSafe(String,String)to strip invalid characters from header values.
-
Fixed issues related to invalid characters being set on HTTP header values.
juneau-rest-client
-
{@link oajrc.RestClient} is now extendible. The constructor has been made public and simplified to:
oajrc.RestClient.RestClient(RestClient.Builder).
-
Duplicate methods between {@link oajrc.RestClient.Builder} and {@link org.apache.http.impl.client.HttpClientBuilder}
have been made deprecated on the former. This eliminates the need to try to keep the two builder classes in
sync.


{% extends 'layout.html' %} {% block title %}Blog Post 1{% endblock %} {% block content %}
Posted on February 2, 2018
"This is a blog!"
A blog for the ensemble of jkfs.


{% extends "base.html" %} {% load markdown_extras %} {% block content %}
{{ poll.description |striptags | force_escape | markdown |safe }}
Promoted polls are listed on our promoted page. Additionaly, the highest amount spent on a poll between active polls gives a winner spot on the homepage.


RCE Capital rises 1.73% on positive technical outlook
by Surin MurugiahKUALA LUMPUR (Nov 15): Shares in RCE Capital Bhd rose 1.73% in the morning session today, following a positive technical outlook on the stock.
At the midday break, RCE Capital added 3 sen to RM1.76, for a market capitalisation of RM649.47 million.
RHB Retail Research said RCE Capital may move higher after it continued holding above the RM1.62 support.
In a trading stocks note today, the research house said given that it has formed a long white candle above the rising 21-day simple moving average (SMA) line, this means that the bullish sentiment has been enhanced.
"A positive bias may emerge above the RM1.69 level, with an exit set below the RM1.62 threshold.
"Towards the upside, the immediate resistance is at the RM1.90 mark. This is followed by the RM2.00 level," it said.


HA-Pen Documentation
This documentation will take you through installing and using HA-Pen.
About HA-Pen
HA-Pen is a webapp built using Bottle that allows you to create timers and control power sockets using the Pi-mote add-on for Raspberry Pis from Energenie.
Once installed and working you will be able to turn sockets on an off by clicking a button on a web page from any device with a browser, plus you can create timers so the sockets switch on and off at set times.
Installation
The installation section will take you through installing HA-Pen and the various dependencies.
Configuration
The config section will take you through the simple config steps.
Usage
The usage section will run through how to use the system, both from the web UI and the command line.
Project structure
The project is laid out as follows:
- app.py - contains the main application logic
- app.wsgi - the settings necessary for the application to run under a WSGI server
- config - contains the various configuration files
- settings.json - the overall application settings
- sockets.json - details of the sockets
- timers.json - all of the timer details for switching sockets on and off
- docs - the various documentation files
- lib - contains the various function files
- energenie_pig.py - functions for turning on/off the sockets using pigpio
- scheduler.py - standalone script that turns the sockets on/off based on timers
- sockets.py - various socket-related functions
- sunrise_sunset.py - a script that calculates the current day's sunrise/sunset times, based on long and lat and updates the timers
- timers.py - various timer-related functions
- static - the files pulled in by the views (CSS and JS)
- js - contains the JS files
- ha.js - contains the various functions used by the web UI
- stylesheets - contains the CSS
- style.css - contains the various styles that control the look and feel of the web UI
- js - contains the JS files
- views - the layout files to control the web UI
- index.html - the main page of the web UI
- sockets.html - the socket page of the web UI
- timer_list.html - a sub-page called by index.html returning the timer list


{% extends "notes/base.html" %} {% block content %}
Your username and password didn't match. Please try again.


Brand development project for Won & McKenzie, a fashion boutique in Dumbo, Brooklyn. Collaterals included logo, poster and UI for website.


Copyright © 2007 The Android Open Source Project
This document lists the instruction formats used by Dalvik bytecode and is meant to be used in conjunction with the bytecode reference document.
The first column in the format table lists the bitwise layout of
the format. It consists of one or more space-separated "words" each of
which describes a 16-bit code unit. Each character in a word
represents four bits, read from high bits to low, with vertical bars
("|
") interspersed to aid in reading. Uppercase letters
in sequence from "A
" are used to indicate fields within
the format (which then get defined further by the syntax column). The term
"op
" is used to indicate the position of an eight-bit
opcode within the format, and similarly "exop
" is used
to indicate an extended sixteen-bit opcode. A slashed zero
("Ø
") is used to indicate that all bits must be
zero in the indicated position.
For the most part, lettering proceeds from earlier code units to later code units, and low-order to high-order within a code unit. However, there are a few exceptions to this general rule, which are done in order to make the naming of similar-meaning parts be the same across different instruction formats. These cases are noted explicitly in the format descriptions.
For example, the format "B|A|op CCCC
" indicates
that the format consists of two 16-bit code units. The first word
consists of the opcode in the low eight bits and a pair of four-bit
values in the high eight bits; and the second word consists of a single
16-bit value.
The second column in the format table indicates the short identifier for the format, which is used in other documents and in code to identify the format.
Most format IDs consist of three characters, two digits followed by a
letter. The first digit indicates the number of 16-bit code units in the
format. The second digit indicates the maximum number of registers that the
format contains (maximum, since some formats can accomodate a variable
number of registers), with the special designation "r
" indicating
that a range of registers is encoded. The final letter semi-mnemonically
indicates the type of any extra data encoded by the format. For example,
format "21t
" is of length two, contains one register reference,
and additionally contains a branch target.
Suggested static linking formats have an additional
"s
" suffix, making them four characters total. Similarly,
suggested "inline" linking formats have an additional "i
"
suffix. (In this context, inline linking is like static linking,
except with more direct ties into a virtual machine's implementation.)
Finally, a couple oddball suggested formats (e.g.,
"20bc
") include two pieces of data which are both
represented in its format ID.
The full list of typecode letters are as follows. Note that some forms have different sizes, depending on the format:
| Mnemonic | Bit Sizes | Meaning |
|---|---|---|
| b | 8 | immediate signed byte |
| c | 16, 32 | constant pool index |
| f | 16 | interface constants (only used in statically linked formats) |
| h | 16 | immediate signed hat (high-order bits of a 32- or 64-bit
value; low-order bits are all 0 )
|
| i | 32 | immediate signed int, or 32-bit float |
| l | 64 | immediate signed long, or 64-bit double |
| m | 16 | method constants (only used in statically linked formats) |
| n | 4 | immediate signed nibble |
| s | 16 | immediate signed short |
| t | 8, 16, 32 | branch target |
| x | 0 | no additional data |
The third column of the format table indicates the human-oriented syntax for instructions which use the indicated format. Each instruction starts with the named opcode and is optionally followed by one or more arguments, themselves separated with commas.
Wherever an argument refers to a field from the first column, the
letter for that field is indicated in the syntax, repeated once for
each four bits of the field. For example, an eight-bit field labeled
"BB
" in the first column would also be labeled
"BB
" in the syntax column.
Arguments which name a register have the form "vX
".
The prefix "v
" was chosen instead of the more common
"r
" exactly to avoid conflicting with (non-virtual) architectures
on which a Dalvik virtual machine might be implemented which themselves
use the prefix "r
" for their registers. (That is, this
decision makes it possible to talk about both virtual and real registers
together without the need for circumlocution.)
Arguments which indicate a literal value have the form
"#+X
". Some formats indicate literals that only
have non-zero bits in their high-order bits; for these, the zeroes
are represented explicitly in the syntax, even though they do not
appear in the bitwise representation.
Arguments which indicate a relative instruction address offset have the
form "+X
".
Arguments which indicate a literal constant pool index have the form
"kind@X
", where "kind
"
indicates which constant pool is being referred to. Each opcode that
uses such a format explicitly allows only one kind of constant; see
the opcode reference to figure out the correspondence. The four
kinds of constant pool are "string
" (string pool index),
"type
" (type pool index), "field
" (field
pool index), and "meth
" (method pool index).
Similar to the representation of constant pool indices, there are
also suggested (optional) forms that indicate prelinked offsets or
indices. There are two types of suggested prelinked value: vtable offsets
(indicated as "vtaboff
") and field offsets (indicated as
"fieldoff
").
In the cases where a format value isn't explictly part of the syntax
but instead picks a variant, each variant is listed with the prefix
"[X=N]
" (e.g., "[A=2]
") to indicate
the correspondence.
| Format | ID | Syntax | Notable Opcodes Covered |
|---|---|---|---|
| N/A | 00x | N/A |
pseudo-format used for unused opcodes; suggested for use as the nominal format for a breakpoint opcode |
| ØØ|op | 10x | op |
|
| B|A|op | 12x | op vA, vB |
|
| 11n | op vA, #+B |
||
| AA|op | 11x | op vAA |
|
| 10t | op +AA |
goto | |
| ØØ|op AAAA | 20t | op +AAAA |
goto/16 |
| AA|op BBBB | 20bc | op AA, kind@BBBB |
suggested format for statically determined verification errors; A is the type of error and B is an index into a type-appropriate table (e.g. method references for a no-such-method error) |
| AA|op BBBB | 22x | op vAA, vBBBB |
|
| 21t | op vAA, +BBBB |
||
| 21s | op vAA, #+BBBB |
||
| 21h | op vAA, #+BBBB0000op vAA, #+BBBB000000000000
|
||
| 21c | op vAA, type@BBBBop vAA, field@BBBBop vAA, string@BBBB
|
check-cast const-class const-string |
|
| AA|op CC|BB | 23x | op vAA, vBB, vCC |
|
| 22b | op vAA, vBB, #+CC |
||
| B|A|op CCCC | 22t | op vA, vB, +CCCC |
|
| 22s | op vA, vB, #+CCCC |
||
| 22c | op vA, vB, type@CCCCop vA, vB, field@CCCC
|
instance-of | |
| 22cs | op vA, vB, fieldoff@CCCC |
suggested format for statically linked field access instructions of format 22c | |
| ØØ|op AAAAlo AAAAhi | 30t | op +AAAAAAAA |
goto/32 |
| ØØ|op AAAA BBBB | 32x | op vAAAA, vBBBB |
|
| AA|op BBBBlo BBBBhi | 31i | op vAA, #+BBBBBBBB |
|
| 31t | op vAA, +BBBBBBBB |
||
| 31c | op vAA, string@BBBBBBBB |
const-string/jumbo | |
| A|G|op BBBB F|E|D|C | 35c | [A=5 ] op {vC, vD, vE, vF, vG},
meth@BBBB[ A=5 ] op {vC, vD, vE, vF, vG},
type@BBBB[ A=4 ] op {vC, vD, vE, vF},
kind @BBBB[ A=3 ] op {vC, vD, vE},
kind @BBBB[ A=2 ] op {vC, vD},
kind @BBBB[ A=1 ] op {vC},
kind @BBBB[ A=0 ] op {},
kind @BBBBThe unusual choice in lettering here reflects a desire to make the count and the reference index have the same label as in format 3rc. |
|
| 35ms | [A=5 ] op {vC, vD, vE, vF, vG},
vtaboff@BBBB[ A=4 ] op {vC, vD, vE, vF},
vtaboff@BBBB[ A=3 ] op {vC, vD, vE},
vtaboff@BBBB[ A=2 ] op {vC, vD},
vtaboff@BBBB[ A=1 ] op {vC},
vtaboff@BBBBThe unusual choice in lettering here reflects a desire to make the count and the reference index have the same label as in format 3rms. |
suggested format for statically linked invoke-virtual
and invoke-super instructions of format 35c
|
|
| 35mi | [A=5 ] op {vC, vD, vE, vF, vG},
inline@BBBB[ A=4 ] op {vC, vD, vE, vF},
inline@BBBB[ A=3 ] op {vC, vD, vE},
inline@BBBB[ A=2 ] op {vC, vD},
inline@BBBB[ A=1 ] op {vC},
inline@BBBBThe unusual choice in lettering here reflects a desire to make the count and the reference index have the same label as in format 3rmi. |
suggested format for inline linked invoke-static
and invoke-virtual instructions of format 35c
|
|
| AA|op BBBB CCCC | 3rc | op {vCCCC .. vNNNN}, meth@BBBBop {vCCCC .. vNNNN}, type@BBBBwhere |
|
| 3rms | op {vCCCC .. vNNNN}, vtaboff@BBBBwhere |
suggested format for statically linked invoke-virtual
and invoke-super instructions of format 3rc
|
|
| 3rmi | op {vCCCC .. vNNNN}, inline@BBBBwhere |
suggested format for inline linked invoke-static
and invoke-virtual instructions of format 3rc
|
|
| AA|op BBBBlo BBBB BBBB BBBBhi | 51l | op vAA, #+BBBBBBBBBBBBBBBB |
const-wide |
| exop BB|AA CCCC | 33x | exop vAA, vBB, vCCCC |
|
| 32s | exop vAA, vBB, #+CCCC |
||
| exop BBBBlo BBBBhi AAAA | 40sc | exop AAAA, kind@BBBBBBBB |
suggested format for statically determined verification errors;
see 20bc , above |
| exop BBBBlo BBBBhi AAAA | 41c | exop vAAAA, field@BBBBBBBBexop vAAAA, type@BBBBBBBB
The unusual choice in lettering here reflects a desire to make the letters match their use in related formats 21c and 31c. |
|
| exop CCCClo CCCChi AAAA BBBB | 52c | exop vAAAA, vBBBB, field@CCCCCCCCexop vAAAA, vBBBB, type@CCCCCCCC
The unusual choice in lettering here reflects a desire to make the letters match their use in related formats 22c and 22cs. |
|
| exop BBBBlo BBBBhi AAAA CCCC | 5rc | exop {vCCCC .. vNNNN}, meth@BBBBBBBBexop {vCCCC .. vNNNN}, type@BBBBBBBBwhere The unusual choice in lettering here reflects a desire to make the letters match their use in related formats 3rc, 3rms, and 3rmi. |


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
IN THE HIGH COURT OF JUDICATURE AT PATNA Criminal Miscellaneous No.34237 of 2018 Arising Out of PS.Case No. -69 Year- 2018 Thana -BARUN District- AURANGABAD ====================================================== Virit Bind @ Bhikhi Bind, S/o Mahadao Bind, R/o Vill.- Harnathpur, P.S.- Sonhan , District- Kaimur (Bihar). .... .... Petitioner/s Versus The State of Bihar .... .... Opposite Party/s ====================================================== Appearance : For the Petitioner/s : Mrs. Leelawati Kumari, Advocate. For the Opposite Party/s : Mr. Sakir Ahmad, A.P.P. ====================================================== CORAM: HONOURABLE MR. JUSTICE SANJAY PRIYA ORAL ORDER
2 20-06-2018 Heard learned counsel for the petitioner and the State.
The petitioner apprehends his arrest in Barun P.S. Case No. 69 of 2018 instituted for the offence under Sections 379, 420/34 of the Indian Penal Code, Sections 4/40 of Bihar Mines Act and Section 15 of Prevention of Pollution Act.
Learned counsel for the petitioner has submitted that petitioner is owner of seized Eicher Tractor bearing BR 45GA/0352. The petitioner was not present on the spot. It has further been submitted that the sand was loaded in the Tractor with valid Challan.
Considering the facts and circumstances of the case, prayer for anticipatory bail of the petitioner is allowed. In the event of surrender/arrest of the petitioner, named above, within six Patna High Court Cr.M isc. No.34237 of 2018 (2) dt.20-06-2018 2/2 weeks from today, in connection with Barun P.S. Case No. 69 of 2018, he shall be released on anticipatory bail on furnishing bail bond of Rs.10,000/- (Ten thousand) with two sureties of the like amount each to the satisfaction of learned Chief Judicial Magistrate, Aurangabad, subject to the conditions as laid down under Section 438 (2) Cr. P.C. with further conditions (1) bailors should be local having sufficient immovable property within the jurisdiction of the court concerned, (2) petitioner shall cooperate in the trial and shall be present on each and every date fixed by the court and his absence on two consecutive dates without proper and reasonable reason will be liable to cancel his bail bond and (3) if petitioner tampers with the evidence or the witnesses of the case, in that case, prosecution will be at liberty to move for cancellation of bail of the petitioner.
(Sanjay Priya, J) S.Ali/-
U T


Messenger:
Didn't I already cover that? Clan Hall registration begins an hour before the contest, and the next Clan Hall War will begin around %next_siege%.


Back to index
In this example, the form is sent directly to the Build Endpoint of the API. This approach is very efficient if you're asking the API to respond with a 302 and handle potential errors (read more).
section-1
section-2
section-3


0.14.0 (13/04/2020)
twenty-first alpha release.
Features and refactoring
- Implemented a new Provider's filter type, which allow to "keep only selected" Provider
-
Allowed changing completion type (Standard / Template) and Provider's filter type
(Keep selected / Hide selected) from the completion pop-up's menu. No need to open Settings
for that from now on! ;)
- For template completion, refactored the "No scope" element to behave better


[viewBag] title = "Chrome" url = "/doc/outils/chrome" layout = "doc" is_hidden = 0 navigation_hidden = 0 ==


Hello, Im Sarah - a Front End Web Developer & UX Designer with a focus on clean code, responsive design, mobile first, and optimal user experience.
The immersion into tech has uncovered a true passion for me. Naturally curious, building code satisfies my propensity towards organization, attention to detail and the intellect, while the complementary design element empowers an intrinsic creative drive.
I enjoy learning as well as the creative process, and I’m happy to have found an outlet that encompasses both, provides opportunity to find innovative solutions, and connects with an ever-growing community of likeminded, passionate problem solvers.
Current Skills & Favorite Tools
Development
- HTML5, CSS3, JavaScript
- WordPress, PHP
- Git Version Control
- GitHub & Terminal
- Visual Studio Code Editor
- Responsive & Mobile Design
- W3C Web Standards, Debugging
Design
- Adobe Creative Suite
- Information Architecture
- UX / UI Design & Principles
- Usability & Universal Design
- Wireframing with XD, Figma
- Visual Design & Branding
- Digital Prototyping, InVision
Research & Quality
- UX User Research & Strategy
- UX Theory & Best Practices
- User Testing & Iteration
- Data Collection & Analysis
- Ideating Solutions
- QA, Troubleshooting
- Data Presentation


LAURA (director: Otto Preminger; screenwriter:from the novel by Vera Caspary/Jay Dratler/Samuel Hoffenstein/Betty Reinhardt; cinematographer: Joseph La Shelle;cast: Gene Tierney (Laura Hunt ), Dana Andrews (Mark McPherson), Clifton Webb (Waldo Lydecker), Vincent Price (Shelby Carpenter), Judith Anderson (Anne Treadwell), Dorothy Adams (Bessie Clary), James Flavin (McAvity), Clyde Fillmore (Bullitt), 1944)
Reviewed by Dennis Schwartz
"Laura" is an elegant but campy B&W "who-dun-what," noted for its witty dialogue and exquisite romantic atmosphere among the upper-class society types being confronted by a detective from the proletarian-class. It is the first major film Preminger directed and arguably his best, in a film that he was originally fired from by 20th Century Fox's studio head, Darryl Zanuck, only to be rehired by him after his replacement Rouben Mamoulian didn't pan out. This didn't stop the constant bickering between Otto and Darryl, as the studio head wanted John Hodiak for the Dana Andrews part, and he did not want newcomer Clifton Webb in the villain role, nor did he want first-time cinematographer Joseph La Shelle to do the photography for the film. It is a good thing Otto won his argument, because his choices all did great jobs, and Webb, LaShell, and Preminger all received Oscar nominations, with only the cinematographer winning. It should also be noted that Jay Dratler, Samuel Hoffenstein, and Betty Reinhardt, were nominated for best screenplay.
The French reviewers in the 1940s were the first to call this kind of dark thriller, a noir film. It is one of six or so films they named, such as "The Maltese Falcon." Though "Laura" was different in nature-it was not based on a hard-boiled novel-it still became a prototype for this emerging genre. "Laura" has a majestic bent to it, exhibited from the very first scene, where a self-centered, debonair columnist/radio personality, with an acerbic wit, Waldo Lydecker (Webb), provides the voiceover, as he sits in his bathtub writing Laura's biography, as the audience tours his swank Manhattan penthouse.  He is being questioned about his relationship with Laura by the detective, Mark McPherson (Dana), who is his complete opposite. He is a ruggedly handsome, muscular type, who speaks in the common-man's vulgar tongue as compared with the snobbish effete lingo of Waldo.
The question of love is posed, as the efficient McPherson wants to know about the relationship between Waldo and the beautiful Laura, believing he can nail the murderer by knowing something about the woman killed. Waldo is portrayed as being obsessed with her, but their relationship was not a sexual one, but one of friendship, where she got her first break through him and she quickly moved up in the advertising world into a position of prominence through her own ability, where she could now afford a luxury townhouse apartment and a maid. When the question of love gets kicked back to the detective by Waldo, as he asks if he's ever been in love, he snappily retorts, "A doll in Washington Heights got a fox fur out of me once."
In Laura's place, Mark sees the portrait of her, and finds her to be captivating, but when asked by Waldo what he thinks, he can only say, "not bad." Waldo volunteers information about how obsessed he is with her and jealous of her other boyfriends in the 5 years he knew her. He tells of Laura falling for the artist who painted her portrait, and how he broke up that relationship by doing a hatchet job on the mediocre artist in his newspaper column, thereby getting Laura to come to her senses and see what a second-rate fellow he was. He also talks about her current boyfriend, Shelby Carpenter (Price), whom he despises as being someone who is a weakling, a scoundrel and a scam artist. Laura's older aunt, Anne Treadwell (Judith), is in love with Shelby, and doesn't care if his character is rotten, even supporting him with money, as the broke society person from Kentucky, whose credentials are dubious, has no shame about his different affairs coinciding.
These three are suspected by the detective, who in his relentless quest to get the murderer, digs into Laura's life. He reads the love letters Waldo wrote her, her diary, and is curious about the gifts Waldo gave her, such as the big clock in her parlor. He wonders about Shelby's alibi and the lies he gets caught telling, and he wonders about the key to Laura's apartment that Shelby said he didn't have but which turns out he did have. He wonders about who is telling the truth about Laura's engagement, when Waldo said she went to her country home for the weekend to think it over whether she should marry Shelby, all because she is perturbed to find out that he is seeing on the sly a model who works in her place. While Shelby maintains that she will surely marry him, there is no question about it. The detective wonders about the aunt, who seems to be obsessed with having Shelby for a lover, whom she considers a kindred spirit, both being nasty.
The sexual nature of the three suspects seems perverse, as homosexual aspects to their character furtively emerges in their mannerisms. The only straight people are Laura and the cop who fell in love with her portrait, a sort of necrophilia type of romantic notion.
The film brought out the following observable things about the suspects: Ann seems more masculine than feminine, Shelby appears to have stereotypical "gay" tendencies, while Waldo is a flaming bitch; as they all exhibit, in the very least, a certain amount of sexual ambiguity.
The plot twist occurs when Laura returns home Monday evening and Mark is sitting in her living room, startled to see her. Recovering from his shock, he learns the body discovered was of the model. He quickly puts the puzzle together and learns that Shelby was with the model in the apartment and that when she answered the door, the intruder fired a shotgun at point-blank range disfiguring her, which is why when the maid discovered the body, it was wrongly identified. He now adds Laura as a possible suspect, believing jealousy could be her motive, as he catches her calling Shelby and secretly meeting him when she leaves her apartment, after she told him she wouldn't, and she also lied when she told him the marriage was off.
What it all boils down to, is melodramatic, leading up to a maddening conclusion, as the prissy he-men, who both seem to be oddly sexually attracted to Laura, become the two most likely suspects. The film's theme of obsession over a love affair, ends on a psychopathic note, showing which of the "sickies" is capable of murder to sustain his egomaniacal desires, not willing to give up his ideal woman to another. As for Mark, Laura was his ideal woman when he viewed her portrait thinking of her as dead, but now that she is alive, the strong-willed and imperfect decision-making woman, becomes a greater challenge to romance, though of all her other lovers, he probably stands the best chance of succeeding.
What made this a special film, a classic, was how stylishly smart it was and the magnificent performances of both Andrews and Webb. The former's performance being done with a subtle wink of an eye, was stolid, steadfast, and no-nonsense, complementing the caustic performance of Webb, who is viewed as someone ailing from a Pygmalion complex. Also adding to the film's aesthetics, was Preminger's impassive direction, allowing the audience to become voyeurs, with his direction offering no resistance for them seeing whatever they have to about these characters; and, finally, there is the arresting cinematography of La Shelle, creating a moody atmosphere and a mise-en-scéne that is provocatively twisted. It is hard to find fault with this very satisfying seductive thriller. The film even had a great theme song, written by David Raksin especially for the film, which takes the same name as the title.
The character Clifton Webb plays is remarkably similar to the daunting New York critic Alexander Woollcott, who presided at the famous Algonquin Round Table, and in one scene Webb is shown seated there when he first meets Gene Tierney, who is trying to get him to endorse a pen her ad company is pushing.
REVIEWED ON 2/9/2000 GRADE: A
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Before Change
sparse_feature_list = [SingleFeat(feat, 1000, hash_flag=True, dtype="string") // since the input is string
for feat in sparse_features]
dense_feature_list = [SingleFeat(feat, 0, )
for feat in dense_features]
// 3.generate input data for model
train, test = train_test_split(data, test_size=0.2)
train_model_input = [train[feat.name].values for feat in sparse_feature_list] + \
[train[feat.name].values for feat in dense_feature_list]
test_model_input = [test[feat.name].values for feat in sparse_feature_list] + \
[test[feat.name].values for feat in dense_feature_list]
// 4.Define Model,train,predict and evaluate
After Change
// 2.set hashing space for each sparse field,and record dense feature field name
fixlen_feature_columns = [SparseFeat(feat, 1000, use_hash=True, dtype="string") // since the input is string
for feat in sparse_features] + [DenseFeat(feat, 1, )
for feat in dense_features]
linear_feature_columns = fixlen_feature_columns
dnn_feature_columns = fixlen_feature_columns
fixlen_feature_names = get_fixlen_feature_names(linear_feature_columns + dnn_feature_columns, )
// 3.generate input data for model
train, test = train_test_split(data, test_size=0.2)
train_model_input = [train[name] for name in fixlen_feature_names]
test_model_input = [test[name] for name in fixlen_feature_names]
// 4.Define Model,train,predict and evaluate
model = DeepFM(linear_feature_columns,dnn_feature_columns, task="binary")