--- layout: post title: How to make a fixed sidebar or header with CSS date: 2012-03-31 20:20:56.000000000 +02:00 type: post published: true status: publish categories: - Web development tags: - css - fixed - header - sidebar meta: _edit_last: '1' _thumbnail_id: '1913' dsq_thread_id: '631498757' author: login: bbWebdesign email<EMAIL_ADDRESS>display_name: Bob first_name: Bob last_name: Belderbos ---
In this post some simple CSS to get you started with a fixed sidebar or header design. I think it is a nice design option. I used the fixed header for my portfolio site. I found a fixed sidebar example at fooljs.com.
I like how Facebook and Twitter have a header with small height and how it always stays on top and in place when you are scrolling the content. In this post I will give you an example of this and of a fixed sidebar. The code can be downloaded from github or, as it is HTML/CSS, you can browse the files here
** I will use the Codesnippets repository on Github from now on to share blog and other code examples. I will migrate some of the code I have at http://bobbelderbos.com/src (previous posts) to have everything stored in one place.
I first include a reset.css to wipe out any browser default styles. I think this is one of the best things you can do when starting to write CSS, to not find any surprises ("huh? it looks different even between modern browsers!") later on.
Next, you can get a simple HTML5 template from this Sitepoint post. For bigger projects I tend to use the HTML5 boilerplate which includes a lot of best practices. So we are going to use some very simple markup, to provide the CSS necessary to get to these two layouts.
See here. We have a "nav" item that is the fixed content, a "content" div that holds "main" and "footer".

Fixed header

Subheader

 ..

 ..
  ..

A simple trick I use regularly is to put temporary borders around the building blocks of my sites:
/* markers for design */ nav { border: 1px solid #999; } #content { border: 1px solid red; } footer { border: 1px solid blue; }
See here
nav { position: fixed; left: 0; top: 0; bottom: 0; background: #f2f2f2; width: 180px; padding: 10px; } .. #content { margin: 0 0 30px 210px; background-color: #eee; } #main { padding: 10px; line-height: 20; /* to fake lot of content / scrolling */ } footer { width: 100%; background-color: #ddd; position: fixed; bottom: 0; left: 200; }
See here
nav { position: fixed; left: 0; top: 0; background: #f2f2f2; width: 100%; heigth: 20px; padding: 10px; z-index: 20; } .. #content { position: relative; top: 40px; background-color: #eee; z-index: 10; } #main { padding: 10px; line-height: 20; /* to fake content with a huge height without much clutter content */ } footer { width: 100%; background-color: #ddd; position: fixed; bottom: 0; left: 200; }
After setting the stacking order with z-index it is better. As w3schools explains: "An element with greater stack order is always in front of an element with a lower stack order."
So by giving "nav" a bigger z-index it stacks on top of #content. Interestingly I found out last week that, if you use plugins like Fancybox you should be conservative with this value. They use 100 for z-index, so when using the max. of 9999 for a block, that block will always sit on top, be careful there!
nav { z-index: 20; } #content { z-index: 10; }
After this CSS it is much better:
And that is it: two simple templates to start a web design with a fixed vertical or horizontal navigation.


Main article: TL Language.
In certain cases, types may depend not only on other types (polymorphism), but also on the parameters of another type (dependent types). The TL language provides very limited support for this functionality: dependence is only allowed on a natural parameter whose type is designated using #
(alias nat
, but this is private -- TL doesn’t currently support this synonym). Values of type # are serialized as 32-bit signed numbers from 0 to 2^31-1.
Suppose we want to use induction to define the types “one integer”, “two integers”, and “three integers”. We could try to define them as follows:
empty = Empty;
single x:int = Single;
pair x:int y:int = Pair;
triple x:int y:int z:int = Triple;
quadruple x:int y:int z:int t:int = Quadruple;
...
or as:
empty = Empty;
single x:int empty = Single;
pair x:int y:single = Pair;
triple x:int yz:pair = Triple;
quadruple x:int yzt:triple = Quadruple;
or as:
tnil = Tuple0;
tcons0 hd:int tl:Tuple0 = Tuple1;
tcons1 hd:int tl:Tuple1 = Tuple2;
tcons2 hd:int tl:Tuple2 = Tuple3;
...
tcons_n hd:int tl:Tuple_n = Tuple_(n+1)
The first two variations lead to the same serialization. For example, (2 3 9):%triple
and (2 (3 9)):%triple
serialize as three 32-bit numbers: 2 3 9
. The last variation better emphasizes the inductive version of the definition, but it uses boxed types. This is good from a theoretical perspective, but it leads to “superfluous” constructor names in serialization.
Therefore, we will write %Type-Ident
to indicate the bare type that corresponds to the boxed type Type-Ident
with a single constructor. If this constructor is named constructor
, then according to the definition %Type-Ident
= %constructor
. Now we can write our definition like this:
tnil = Tuple0;
tcons_n hd:int tl:%Tuple_n = Tuple_(n+1)
If we now abstract n out of the name of the type name and make it like a parameter for a polymorphic (dependent, to be more exact) type, then something like the following can be written in a suitable functional language:
NewType Tuple (n : #) :=
| tnil = Tuple 0
| tcons n:# hd:int tl:%(Tuple n) = Tuple (S n)
EndType;
In the TL language, it looks like this:
tnil = Tuple 0;
tcons {n:#} hd:int tl:%(Tuple n) = Tuple (S n);
The function S : # -> #
and the constant O : #
(it is 0
) are the function for the next natural number (S n = n + 1
) and the constant null. Therefore, the type #
(alias nat
) behaves as if it were defined in TL using the constructors
O = nat;
S nat = nat;
or, using syntax more typical of other functional languages,
NewType nat :=
| O
| S nat
EndType;
Types of all defined combinators:
O : #
S : # -> #
Tuple : # -> Type
tnil : Tuple 0
tcons : forall n : #, int -> Tuple n -> Tuple (S n)
or
Tuple : forall n : #, Type;
tcons : forall n : #, forall hd : int, forall tl : Tuple n, Tuple (S n)
Note that in this case the constructor tnil
does not depend on the parameter n, while tcons
does.
In an analogous manner, it is possible to define a complete binary tree of height h with strings in the leaf nodes:
tleaf value:string = BinTree 0;
tnode {h:#} left:(BinTree h) right:(BinTree h) = BinTree (S h);
Or a random tree whose leaf nodes are all a distance of h from the root and whose nodes are all labeled with integers:
hleaf value:int = Tree 0;
hnode {n:#} left:(Tree n) next:(Tree (S n)) = Tree (S n)
hnil {n:#} = Tree (S n)
Another version:
hleaf' value:int = Tree' 0;
hnode' {n:#} children:(list (Tree' n)) = Tree' (S n)
Let us try to define a type Tuple X n
whose values are n-tuples of type X
values. In this way, Tuple
will be simultaneously polymorphic and dependent:
Tuple : Type -> # -> Type;
In the familiar syntax of functional languages:
NewType Tuple {X : Type} {n : #} :=
| vnil : Tuple X 0
| vcons {n:#} hd:X tl:%(Tuple X n) : Tuple X (S n)
EndType
or, in TL syntax,
vnil {X:Type} = Tuple X 0;
vcons {X:Type} {n:#} tl:(%Tuple X n) = Tuple X S n
In the end we obtain terms for the following types:
vnil : forall X : Type, Tuple X 0
vcons : forall X : Type, forall n : #, X -> Tuple X n -> Tuple X (S n)
or
vnil : forall X : Type, Tuple X 0
vcons : forall X : Type, forall n : #, forall hd : X, forall tl : Tuple X n, Tuple X (S n)
The Tuple
we just defined differs from the built-in Vector
type. Specifically, the Vector
type formally depends on a single argument (a type), but our Tuple
depends on two (a type and a number):
Tuple : Type -> # -> Type;
Vector : Type -> Type;
The built-in Vector
could be defined in terms of our Tuple
using “summing across all n : #":
vector {X:Type} n:# v:(%Tuple X n) = Vector X;
Nevertheless, our Tuple
has its advantages. For example, we can define data types such as:
matrix_10x10 a:(%Tuple (%Tuple double 10) 10) = Matrix_10x10;
In any event, remember that during calculation of the matrix_10x10
combinator’s number, all parentheses must be removed and the CRC32 of the string matrix_10x10 a:%Tuple %Tuple double 10 10 = Matrix_10x10
must be computed.
Moreover, we can define arbitrarily-sized matrices:
matrix {X:Type} m:# n:# a:(%Tuple (%Tuple X m) n) = Matrix X;
In this case using vector would result in storing the length of a row (m) in each row, e.g. n times.
Note that the serializations of values of type %Tuple X n
and vector X
(also known as %vector X
and %Vector X
) nearly match when n > 0: in both cases we obtain a single 32-bit number (equal to n-1 or n depending on the version) followed by the serializations of n objects of type X. (This is slightly untrue: values of type %Tuple X n
can only be serialized if n is a constant or value known from one of the preceding fields of the enclosing entry; but then this n won’t be serialized explicitly anywhere).
In view of the importance of the construction presented above, it is built into the TL language in the following manner. A substructure in the form of [ array-field-name ":" ] [ nat-ident "" ] "[" field-descr ... "]” may be used in the declaration of any combinator, where nat-ident* is the name of any previously encountered field of type # (if it is not explicitly indicated, the most recent is used). In abstract, this substructure is equivalent to:
aux_type *field-descr* ... = AuxType;
*current_constructor* ... [ *array-field-name* ":" ] (%Tuple aux_type *nat-ident*)
For example, 10x10 matrices, vectors, and arbitrary matrices may be defined in the following way:
matrix {X:Type} m:# n:# a:n*[ m*[ X ] ] = Matrix X;
matrix_10x10 a:10*[ 10*[ double ]] = Matrix_10x10;
vector {X:Type} # [ X ] = Vector X;
We have already encountered the last version as a “definition” of the “built-in type” Vector
.
Of course, several fields, as complex as desired, may be within the repeating part. Furthermore, besides using n as a repeat counter, one may use expressions of the form (n+const) and (const+n), where const is a small nonnegative constant, which are shorthand for S (S ( ... (S n) ... )):
repeat_np1 n:# a:(S n)*[ key:string value:string ] = Dictionary;
To calculate the CRC32 these expressions are converted to expressions of the form (const+X)
without internal spaces. Additionally, the *
in this case is not set off by spaces on the left and right.
Serialization of dependent types and polymorphic types is not a fundamental challenge: we have combinators with non-zero arity with Type values. For example, the type Tuple double 10 : Type
serializes to 'Tuple' '%double' 10
. Note that at present in practice there is virtually no need to serialize types, whether dependent or not.
Optional combinator parameters in TL must possess the following properties:
Optional parameters must be precisely ythe combinator’s first several arguments;
The value of any optional parameter must be entirely determined by the combinator’s result type.
For example, in cons {X:Type} hd:X tl:(list X) = list X
the parameter X
may be made optional, because it is located at the very beginning of the argument list and is unambiguously determined by the list X
result type. Similarly, in tcons {X:Type} {n:#} hd:X tl:(%Tuple X n) = Tuple X (S n)
the values of X and n are completely determined based on the Tuple X (S n)
result type, therefore they made be made optional parameters.
It usually makes sense to move all of a constructor’s arguments satisfying the second condition to the beginning of the list, arrange them in the order they appear in the result type’s parameters, and make them optional. Given such an approach, the full version of a constructor is rarely needed -- only when we want to transmit the value of the polymorphic or dependent type as a value of type Object. In all other cases, the type of the expected value from the context is already known, which means that all optional parameters can be recovered during decomposition.


Document Information
Preface
Part I Introduction
1. Overview
2. Using the Tutorial Examples
Part II The Web Tier
3. Getting Started with Web Applications
4. JavaServer Faces Technology
5. Introduction to Facelets
6. Expression Language
7. Using JavaServer Faces Technology in Web Pages
8. Using Converters, Listeners, and Validators
9. Developing with JavaServer Faces Technology
10. JavaServer Faces Technology: Advanced Concepts
11. Using Ajax with JavaServer Faces Technology
12. Composite Components: Advanced Topics and Example
13. Creating Custom UI Components and Other Custom Objects
14. Configuring JavaServer Faces Applications
15. Java Servlet Technology
16. Java Servlet Technology: Advanced Topics
17. Internationalizing and Localizing Web Applications
Part III Web Services
18. Introduction to Web Services
19. Building Web Services with JAX-WS
20. Building RESTful Web Services with JAX-RS
21. JAX-RS: Advanced Topics and Example
Part IV Enterprise Beans
22. Enterprise Beans
23. Getting Started with Enterprise Beans
24. Running the Enterprise Bean Examples
25. A Message-Driven Bean Example
26. Using the Embedded Enterprise Bean Container
27. Using Asynchronous Method Invocation in Session Beans
Part V Contexts and Dependency Injection for the Java EE Platform
28. Introduction to Contexts and Dependency Injection for the Java EE Platform
29. Running the Basic Contexts and Dependency Injection Examples
30. Contexts and Dependency Injection for the Java EE Platform: Advanced Topics
31. Running the Advanced Contexts and Dependency Injection Examples
Part VI Persistence
32. Introduction to the Java Persistence API
33. Running the Persistence Examples
34. The Java Persistence Query Language
35. Using the Criteria API to Create Queries
36. Creating and Using String-Based Criteria Queries
37. Controlling Concurrent Access to Entity Data with Locking
38. Improving the Performance of Java Persistence API Applications By Setting a Second-Level Cache
Part VII Security
39. Introduction to Security in the Java EE Platform
40. Getting Started Securing Web Applications
41. Getting Started Securing Enterprise Applications
42. Java EE Security: Advanced Topics and Example
Part VIII Java EE Supporting Technologies
43. Introduction to Java EE Supporting Technologies
44. Transactions
45. Resources and Resource Adapters
46. Running the Resource Adapter Example
47. Java Message Service Concepts
48. Java Message Service Examples
49. Bean Validation: Advanced Topics
50. Using Java EE Interceptors
Part IX Case Studies
51. Duke's Bookstore Case Study Example
52. Duke's Tutoring Case Study Example
53. Duke's Forest Case Study Example
Design and Architecture of Duke's Forest
The Events Project
The Entities Project
The Duke's Payment Project
The Duke's Resources Project
The Duke's Store Project
Enterprise Beans Used in Duke's Store
Facelets Files Used in the Main Interface of Duke's Store
Facelets Files Used in the Administration Interface of Duke's Store
Managed Beans Used in Duke's Store
Helper Classes Used in Duke's Store
Qualifiers Used in Duke's Store
Event Handlers Used in Duke's Store
Properties Files Used in Duke's Store
Deployment Descriptors Used in Duke's Store
The Duke's Shipment Project
Enterprise Beans Used in Duke's Shipment
Facelets Files Used in Duke's Shipment
Managed Beans Used in Duke's Shipment
Helper Classes Used in Duke's Shipment
Qualifiers Used in Duke's Shipment
Properties Files Used in Duke's Shipment
Deployment Descriptors Used in Duke's Shipment
Running the Duke's Forest Application
To Register as a Duke's Store Customer
To Purchase Products
To Approve Shipment of a Product
To Create a New Product
Index
|
|
Building and Deploying the Duke's Forest Case Study Application
You can use NetBeans IDE or Ant to build and deploy Duke's
Forest. The prerequisite task requires Ant.
Prerequisite Task
To Create the JDBC Realm and Populate the Database
Before You Begin You must have already configured GlassFish Server as a Java EE server
in NetBeans IDE, as described in To Add GlassFish Server as a Server in NetBeans IDE.
- In a terminal window, go to:
tut-install/examples/case-studies/dukes-forest/entities/
- Execute the create-forest-realm Ant task:
ant create-forest-realm This task creates a JDBC connection pool and a JDBC resource as
well as the realm.
- Execute the following Ant task:
ant This task creates the tables (dropping any existing tables) and builds the JAR
file. Ignore any errors if you are running the task for the
first time.
To Build and Deploy the Duke's Forest Application Using NetBeans IDE
- From the File menu, choose Open Project.
- In the Open Project dialog, navigate to:
tut-install/examples/case-studies/dukes-forest/
- Select the dukes-store folder.
- Select the Open Required Projects check box.
- Click Open Project.
The IDE will open the dukes-store, dukes-resources, entities, and events projects. The project opens with a message stating that there is a data
source problem.
- Right-click the project and select Resolve Data Source Problem.
- In the dialog box that opens, select jdbc/forest and click Add Connection.
- Click Finish.
The connection to the forest database is now established. If the project still indicates that there is a datasource problem, but the
dialog does not indicate a missing connection, close and reopen the project.
- Repeat steps 1–5 to open the dukes-shipment project.
- Repeat steps 1–5 to open the dukes-payment project.
- Right-click the events project and select Build.
- Right-click the dukes-resources project and select Build.
- Right-click the dukes-payment project and select Deploy.
- Right-click the dukes-store project and select Deploy.
- Right-click the dukes-shipment project and select Deploy.
The dukes-shipment project requires the file jersey-client.jar, which is located in as-install/lib/modules/. If
you get a Resolve References error when you first try to build dukes-shipment, you
can resolve the error by locating this file.
To Build and Deploy the Duke's Forest Application Using Ant
- In a terminal window, go to:
tut-install/examples/case-studies/dukes-forest/events/
- Enter the following command to build the events.jar file:
ant
- Go to the dukes-resources directory:
cd ../dukes-resources
- Enter the following command to build the dukes-resources.jar file:
ant
- Go to the dukes-payment directory:
cd ../dukes-payment
- Enter the following command:
ant all
- Go to the dukes-store directory:
cd ../dukes-store
- Enter the following command:
ant all
- Go to the dukes-shipment directory:
cd ../dukes-shipment
- Enter the following command:
ant all
Copyright © 2012, Oracle and/or its affiliates. All rights reserved. Legal Notices
|


Babcock Expells Students Involved In Sex Tape, Release Statement
by Faderera FaladeThe expulsion of the students involved in the leaked sex tape which went viral on social media has been confirmed by the management of Babcock University.
Through a statement released by the school’s Director of Communication and Marketing, Joshua Suleiman.
According to the statement, the male student had in February 2019 been expelled and was undergoing rehabilitation for different destructive addictions.
it was also learnt that the female student who is a 300 level student of Accounting had sex with him when she went to visit him in the hospital where he was admitted in April.
The management of Babcock University further stated that the female student said to be daughter of a Senior Pastor of Calvary Bible Church, has also been expelled for violation of the University’s rules and regulations.
See the statement below:


Toggle navigation
Book Trading Club
All Books
{{#if user}}
My Books
Post a Book
My Trades
My Profile
Logout
{{else}}
Login with Twitter
{{/if}}
Post a New Book
Book title
Powered by Google Books API
Clear
Go!


MySQL's UUID() and RAND() functions both provide with (pseudo) indeterministic result. UUID()'s result is moreover bound to the host on which it executes. For this reason, both are unsafe to replicate with STATEMENT binlog format. As an example, consider:
master> create table test.uuid_test (id int, u varchar(64)); master> insert into test.uuid_test values (1, UUID()); Query OK, 1 row affected, 1 warning (0.03 sec) master> select * from test.uuid_test; +------+--------------------------------------+ | id | u | +------+--------------------------------------+ | 1 | 7e3596d8-56ac-11e4-b284-3c970ea31ea8 | +------+--------------------------------------+
The warning we got on the insert directly relates to the following inconsistency on a slave:
slave1> select * from test.uuid_test; +------+--------------------------------------+ | id | u | +------+--------------------------------------+ | 1 | 7e379d63-56ac-11e4-8477-3c970ea31ea8 | +------+--------------------------------------+
The data on the slave is clearly inconsistent with the master's. The slave, replicating via STATEMENT binlog format, re-executes the INSERT command and gets a different UUID value.
External
One solution to the above is to generate the UUID value from your application. By the time MySQL gets the INSERT statement, the UUID value is a constant string, as far as MySQL is concerned.
Internal
However there's a way to do it from within MySQL, by decoupling the UUID() function from the INSERT statement. It takes a session variable. Consider:
master> set @safe_uuid := UUID(); Query OK, 0 rows affected (0.00 sec) master> insert into test.uuid_test values (2, @safe_uuid); Query OK, 1 row affected (0.02 sec) master> select * from test.uuid_test; +------+--------------------------------------+ | id | u | +------+--------------------------------------+ | 1 | 7e3596d8-56ac-11e4-b284-3c970ea31ea8 | | 2 | 29c51fb9-56ad-11e4-b284-3c970ea31ea8 | +------+--------------------------------------+
And on a slave:
slave1> select * from test.uuid_test; +------+--------------------------------------+ | id | u | +------+--------------------------------------+ | 1 | 7e379d63-56ac-11e4-8477-3c970ea31ea8 | | 2 | 29c51fb9-56ad-11e4-b284-3c970ea31ea8 | +------+--------------------------------------+
The reason why this succeeds is that MySQL stores session variable values that are being used by DML queries in the binary log. It just so happened that @safe_uuid was assigned the UUID() value, but it could just as well have been assigned a constant or other computation. MySQL stored the resulting value into the binary log, where it is forces upon the slave to use. Check out this binary log snippet:
# at 14251 #141018 12:57:35 server id 1 end_log_pos 14319 Query thread_id=2 exec_time=0 error_code=0 SET TIMESTAMP=1413626255/*!*/; SET @@session.sql_auto_is_null=0/*!*/; BEGIN /*!*/; # at 14319 #141018 12:57:35 server id 1 end_log_pos 14397 User_var SET @`safe_uuid`:=_utf8 0x32396335316662392D353661642D313165342D623238342D336339373065613331656138 COLLATE `utf8_general_ci`/*!*/; # at 14397 #141018 12:57:35 server id 1 end_log_pos 14509 Query thread_id=2 exec_time=0 error_code=0 SET TIMESTAMP=1413626255/*!*/; insert into test.uuid_test values (2, @safe_uuid) /*!*/; # at 14509 #141018 12:57:35 server id 1 end_log_pos 14536 Xid = 145 COMMIT/*!*/;
The same can be applied for RAND(). Funny thing about RAND() is that it is already taken care of by the binary log via SET @@RAND_SEED1, SET @@RAND_SEED2 statements (i.e. it works), though the documentation clearly states it is unsafe.
With Row Based Replication (RBR) the problem never arises in the first place since the binlog contains the values of the new/updated rows.
comments powered by Disqus


| Surface | Material | Comments | |||
| Surface Name | Specific | No. | Name | No. | |
| Ceiling | Ceiling | 144 | Smooth Brick | 1000 | |
| Walls | 4 to 12 | ||||
| Floor | Back Wall | 152 | |||
| Gap Wood | Back Wall | 1918 | |||
| Soft Plastic | Fire exit surroundings | 14, 17, 28, 38 | Canvas Covering | 10008 | |
| Soft Plastic | Roof Hangings | 1885 to 1916 | Canvas Covering | 10008 | Type: FRACTIONAL |
| Radiator | Radiator Grills | 146 | Ventilation Grills | 100009 | |
| 196 | |||||
| 908 | |||||
| 191 | |||||
| Roof Grills | 886 | ||||
| 1291 | |||||
| 1617 | |||||
| 1514 | |||||
| 893 | |||||
| Radiator & Soft Metal | Radiators and other | All other | Steel Trapez | 5000 | |
| Door | Computer station | 951 & 954 | |||
| Table legs | 1314 to 1318 | ||||
| 1323 | |||||
| 1326 to 1359 | |||||
| Door | Wooden Doors | 952 to 960 | Solid Wooden Door | 10007 | |
| Gap Wood | Window pane | 1876 to 1878 | Solid Wooden Door | 10007 | |
| Metal | Door Metal (Grill) | 41 & 42 | Ventilation Grills | 10009 | |
| Floor | Entire Floor | 142 | Floating Wooden Floor | 3001 | |
| Gap Wood | Under Seating | 1917 | Floating Wooden Floor | 3001 | |
| Gap Wood | Front of seating | 1879 | Solid Wooden Door | 10007 | Transparency: 0.3 |
| Wall | Back wall window frame | 45,47,50,54 | Solid Wooden Door | 10007 | |
| 57 to 80 | |||||
| 1879 to 1884 | |||||
| BlackBoard | 1360 & 1361 | Slate | 14301 | Data taken from [Kovalchik] | |
| Plastic Hard | Plastic Lighting & Projectors | 1635 to 1874 | Plastic | 14302 | Data from [http://www.acoustic.ua/st/web_absorption_data_eng.pdf] |
| 1628 to 1630 | |||||
| 921 to 1626 | |||||
| 929 | |||||
| Glass | All Glass | All Glass | Glass, Ordinary window glass (harris 1991) | 10006 | |
| Glass | All Glass | All Glass | Glass, Ordinary window glass (harris 1991) | 10006 | |
| Layer0 | Metal Frames | 122 to 139 | Steel Trapez | 5000 | |
| Ceiling | Smaller roof vents | 99 to 118 | Steel Trapez | 5000 | |


Current work
Primarily I am the lead orbit determination analyst for the
Parker Solar Probe mission.
This revolutionary spacecraft will launch in July-August of 2018 and
will fly faster and closer to the Sun than any other man-made object.
The environment is incredibly challenging, not to mention very hot!
This probe aims to unlock the mysteries of the solar corona, and we
are busily preparing for launch. I am a member of the
Psyche mission design and navigation team, working in collaboration with
my Alma Mater ASU. I contribute to a variety of flight, pre-flight, and research
tasks touching many aspects of robotic and human space exploration.
Research Collaborator Websites
Journal Articles
- Y. Guo, P. Thompson, J. Wirzburger, N. Pinkine, S. Bushman,
T. Goodson, R. Haw, J. Hudson, D. Jones, et al.,
"Execution of Parker Solar Probe’s Unprecedented Flight to the Sun and
Early Results,"
Acta Astronautica, 2020.
- D.R. Jones,
"Trajectories for Flyby Sample Return at Icy Moons,"
Journal of Spacecraft and Rockets, Vol. 55, No. 3, 2018, pp. 529-540.
- D.R. Jones,
"Trajectories for Flyby Sample Return at Icy Moons,"
Journal of Spacecraft and Rockets, Vol. 55, No. 3, 2018, pp. 529-540.
- M. Jesick, S. Demcak, B. Young, D.R. Jones, et al.,
"Navigation Overview for the Mars Atmosphere and Volatile Evolution
Mission,"
Journal of Spacecraft and Rockets, Vol. 54, No. 1, 2017, pp. 29-43.
- D.R. Jones and H. Schaub
"Collinear Three-Craft Coulomb Formation Stability Analysis and Control"
Journal of Guidance, Control, and Dynamics, Vol. 37, No. 1, 2014, pp. 224-232.
- D.R. Jones, D.R. and Schaub, H.,
"Periodic relative orbits of two spacecraft subject to
differential gravity and electrostatic forcing,"
Acta Astronautica, Vol. 89, 2013, pp. 21-30.
- Jones, D.R. and Schaub, H.,
"Optimal reconfigurations of two-craft coulomb formations
along manifolds,"
Acta Astronautica, Vol. 83, 2013, pp. 108-118.
- Jones, D.R. and Ocampo, C.,
"Optimization of impulsive trajectories between a circular orbit and
a hyperbolic asymptote,"
Journal of Guidance, Control, and Dynamics, Vol. 35, No. 1, 2012,
pp. 234-244.
Conference Papers
- Y. Guo, P. Thompson, J. Wirzburger, N. Pinkine, S. Bushman,
T. Goodson, R. Haw, J. Hudson, D. Jones, et al.,
"Execution of Parker Solar Probe’s Unprecedented Flight to the Sun and
Early Results,"
70th International Astronautical Congress, Washington, DC, October 21-25,
2019.
- N. Bradley, J.S. Snyder, D.R. Jones, D. Trofimov, and D. Koh,
"Navigation Models for Psyche Electric Propulsion Uncertainty,"
AAS/AIAA Astrodynamics Specialists Conference, Portland, ME, August 2019.
- S. Hernandez, S. Campagnola, and D.R. Jones,
"An Analytical Approach to the Ballistic Cycler Problem,"
AAS/AIAA Space Flight Mechanics Meeting, Ka'anapali, HI, January 2019.
- P. Valerino, P. Thompson, D.R. Jones, et al.,
"Charting a Course to the Sun: Flight Path Control for Parker Solar Probe,"
AAS/AIAA Space Flight Mechanics Meeting, Ka'anapali, HI, January 2019.
- D.R. Jones, S. Hernandez and M. Jesick,
"Low-Excess Speed Triple Cyclers of Venus, Earth, and Mars,”
AAS/AIAA Astrodynamics Specialists Conference, Stevenson, WA, August 2017.
- S. Hernandez, D.R. Jones and M. Jesick,
"A Class of Io-Europa-Ganymede Triple Cyclers,”
AAS/AIAA Astrodynamics Specialists Conference, Stevenson, WA, August 2017.
- D.R. Jones, P. Thompson, T. Goodson, et al.,
“Orbit Determination Covariance Analyses for the Parker Solar Probe Mission,”
AAS/AIAA Astrodynamics Specialists Conference, Stevenson, WA, August 2017.
- P. Thompson, D.R. Jones, T. Goodson, et al.,
“Parker Solar Probe Navigation: One Year From Launch”,
AAS/AIAA Astrodynamics Specialists Conference, Stevenson, WA, August 2017.
- P. Valerino, P. Thompson, D.R. Jones, et al.,
“Flight Path Control Analysis for Parker Solar Probe”,
AAS/AIAA Astrodynamics Specialists Conference, Stevenson, WA, August 2017.
- A. Petropoulos, D. Grebow, D.R. Jones, et al.,
“GTOC9: Methods and Results from the Jet Propulsion Laboratory Team,"
31st International Symposium on Space Technology and Science,
Matsuyama, Japan, June 2017.
- J. Thangavelautham, A. Rhoden and D.R. Jones,
“The Opportunities and Challenges of GNC on a Europa Cubesat,”
AAS Guidance and Control Conference, Breckenridge, CO, February 2017.
- D.R. Jones, T. Goodson, P. Thompson, P. Valerino, and J. Williams,
"Solar Probe Plus: Unique Navigation Modeling Challenges,"
AIAA Astrodynamics Specialists Conference, Long Beach, CA, September 2016.
- D.R. Jones,
"Trajectories for Europa Flyby Sample Return,"
AIAA Astrodynamics Specialists Conference, Long Beach, CA, September 2016.
- D.R. Jones,
"Trajectories for Flyby Sample Return at Saturn's Moons,"
AIAA Astrodynamics Specialists Conference, Long Beach, CA, September 2016.
- M. Jesick, S. Demcak, B. Young, D. Jones, et al.
"Maven Navigation Overview,"
AAS Space Flight Mechanics Meeting, Napa, CA, February 2016.
- D.R. Jones, T. Lam, N. Trawny, and C. Lee,
"Using MAVEN Onboard Telemetry for Orbit Determination,"
AAS Space Flight Mechanics Meeting, Willimansburg, VA,
January-February 2015.
- D.R. Jones and H. Schaub,
"Periodic Relative Orbits of Two Spacecraft Subject to
Differential Gravity and Coulomb Forces,"
5th International Conference on Spacecraft Formation Flying
Missions and Technologies, Munich, Germany, May 2013.
- D.R. Jones and H. Schaub,
"Collinear Three-Craft Coulomb Formation Stability
Analysis and Control,"
AIAA/AAS Astrodynamics Specialist Conference, Minneapolis,
MN, August 2012.
- D.R. Jones,
"Optimal Reconfigurations of Coulomb Formations along
Invariant Manifolds,"
AAS Space Flight Mechanics Meeting, Charleston, SC,
January-February 2012.
- D.R. Jones, and C. Ocampo,
"Optimal Impulsive Escape Trajectories from a Circular Orbit
to a Hyperbolic Excess Velocity Vector,"
AAS/AIAA Astrodynamics Specialist Conference, Toronto, Canada,
August 2010.
PhD Dissertation


You are looking at Birdwatch, an open source side project for tweet stream analysis. The application subscribes to all tweets that contain a certain term, e.g. Ferguson. All matching tweets are available for further search and analysis. Every search is updated in (near) real time. Typically, when you tweet something containing the term, you should see your tweet appear in the latest section within one or two seconds.
Multiple versions of this application exist, each of which is written in different languages and technologies. The main idea behind this application is to play around with different ways of programmatically reasoning about a stream of information.
The incarnation of the application that you are looking at right now has been written in Clojure on the server side as well as ClojureScript and Om, plus D3, plain ReactJS and Rickshaw for the graphs / charts.
When the application starts, it loads the last 2000 tweets matching a search, with * for matching all tweets as the default search. The search result will then be updated in real time. In the navigation bar, you can see the total count of tweets currently loaded. On the left side, tweets are displayed in different sort orders:
You can respond to, retweet and favorite a tweet directly from this application by using the little icons on the lower right of the tweet frames.
On the right side there are several charts. On top is a time series chart that displays how the search results were distributed over time. Below is a word cloud with the size of a word signifying how often it appeared in the results. Below is a bar chart showing the top 25 words and their individual trend over time. The words in both the word cloud and the bar chart are clickable, with the word then appearing in the search bar. The search bar initiates a new, refined search. At the same time, the **URL** changes so that you can bookmark a specific search or share a link.
Feedback is very welcome. Ideally, the author of this application can turn your feedback into a useful application. If there is any feature that you find useful, please do not hesitate to contact the author. You can find the contact details on the GitHub profile.
You can download and use this application for yourself and monitor the topics you are interested in on Twitter. Here's the source code: https://github.com/matthiasn/BirdWatch
There are multiple blog articles that explain the application in detail:
Note that except for the most recent one, the article refer to previous versions of this application. A series of articles describing the all-Clojure version will be out soon. Follow @matthiasnehlsen and subscribe to the mailing list at matthiasnehlsen.com to be notified of the articles.


Operators (240)
Acadian Gas Gathering System
Acadian Gas Pipeline Sys
Acadian Haynesville Pipeline
Algonquin Gas Trans Co
Alliance Pipeline System
Amoco Pipeline Co
ANR Pipeline Co
ANR Storage Co
Arkansas Western LLC
Atmos Energy (United Cities Gas Co)
Atmos Pipeline - Texas
Bighorn Gathering Header
Bison Pipeline
Black Marlin Pipeline Co
Blue Dolphin Pipeline Co
Bluewater Pipeline Co
Bridgeline Holdings Pipeline LP
Brooklyn Union Gas Co
California Gas Transmission Co
Canyon Creek Compression Co
Canyon Express Gathering System
Cardinal Pipeline Co
Centana Pipeline Co (LA)
Centana Pipeline Co (TX)
CenterPoint Energy GasTrans Co
Centra Minnesota Pipeline Co
Centra Pipeline Co
Chandeleur Pipeline Co
Chandeleur Pipeline Co (MAGS)
Cheyenne Plains Pipeline Co
Cimarron Pipeline
Cleoprata Offshore System
Colorado Interstate Gas Co
Columbia Gas Trans Co
Columbia Gulf Pipeline
Comanche Trail Pipeline
Constitution Pipeline
Coos County Pipeline
Coral Energy Pipeline Co
Cornerstone Pipeline Co
Cove Point Pipeline
Creole Pipeline Co
Crossroads Pipeline Co
Crosstex Alabama System
Crosstex Arkoma System
Crosstex Mississippi Pipeline
Crosstex Texas Systems
Dauphin Island Gathering System
Destin Pipeline Offshore (SHELL)
Discovery Pipeline System
Dominion Transmission Co
Dow Pipeline Co (LA)
Dow Pipeline Co (TX)
East Break Gathering System
East Ohio Gas Co
East Tennessee Gas Co
Eastern Shore Nat Gas Co
El Paso Natural Gas Co
El Paso Texas Pipeline Co
Elba Express Pipeline
Empire Pipeline
Empire Pipeline Co
Enbridge Pipelines (AlaTenn)
Enbridge Pipelines (East Texas)
Enbridge Pipelines (UTOS)
Energy Transfer Co
Energy Transfer LP
Energy Transfer Partners LP
EnergyNorth Nat Gas Co
Enogex Inc
Enterprise Products Partners
Equitrans Inc
ETC Tiger Pipeline
Evangeline Gas Pipeline
Fayetteville Express Pipeline
Florida Gas Trans Co
Florida Southeast Connection
Fort Union Gathering Header
Garden Banks Auger 1 Line
Garden Banks Auger 2 Line
Garden Banks Gathering Sys
Gas Transmission - Northwest
Granite State Gas Trans Co
Grasslands Pipeline
Great Lakes Gas Trans Co
Green Canyon System (Transco)
Guardian Pipeline Co
Gulf South Pipeline Co
Gulfstream Pipeline Co
Heartland Pipeline Co
High Island Offshore
Hope Natural Gas Co
Horizon Pipeline Co
Houston Pipeline Co
Hutchinson Pipeline
Impulsora Pipeline
Independence Trail Pipeline Co
Iroquois Gas Trans Co
Jonah Gas Pipeline System
Kelso-Beaver Pipeline
Kenai Kachemak Pipeline
Kentucky-West Virginia Gas Co
Kern River Gas Trans Co
KeyStone Gas (Sold to in 2005)
Kinder Morgan Louisiana Pipeline
Kinder Morgan Texas Pipeline Co
KO Transmission Co
Lost Creek Gathering Header
Louisiana Gas Co
Louisiana Intrastate Gas Co
Magnolia Offshore Pipeline System
Manta Ray Gathering System
Maritimes & Northeast PL US
Merna Pipeline (WFS)
MGTC Pipeline System
Michcon Gas Co
Michigan Gas Storage Co
Midcontinent Express Pipeline
Midla-Natchez Pipeline
Midwestern Gas Trans Co
MIGC Pipeline System
Millennium Pipeline Co
Mississippi Canyon Gathering
Mississippi Canyon Gathering (MARS)
Mississippi Canyon Gathering (Shell)
Mississippi Canyon Gathering (URSA)
Mississippi Canyon Gathering System
Mississippi River Trans Corp
Mississippi Valley Gas Co
Missouri Gas Co
Missouri Interstate Gas, LLC
Missouri Pipeline Co
Missouri Public Service Co
Mojave Pipeline Co
Monterey Pipeline Co
Mustang Fuel Co
National Fuel Gas Distr Co
National Fuel Gas Supply Co
Natural Gas PL Co of Am
Nautilus Pipeline System
Nemo Offshore Pipeline System
NET Mexico Pipeline
Nora Transmission Co
Norse Pipeline LLC
North Baja Pipeline Co
North Coast Gas Transmission Co
North Country Pipeline Co
North Penn Gas Co
Northern Border PL Co
Northern Illinois Gas Co
Northern Natural Gas Co
Northern Utilities (ME)
Northwest Pipeline
Northwestern Energy Co
Oasis / Energy Transfer Co
Oasis Gas Pipeline Co
Okeanos Offshore Pipeline System
Oklahoma Texas Gas Co
ONEOK Gas Transmission LLC
ONEOK Gas Transportation LLC
ONEOK Westex Pipeline
Overland Trails Trans Co
Overthrust Pipeline Co
Ozark Gas Transmission, LLC
Paiute Pipeline Co
Panhandle Eastern PL Co
Panther Interstate Pipeline LLC
Pecan Pipeline Company
Pelican Gas Gathering Sys
Penn York Energy Co
Peoples Gas Co (TX)
Petal Gas Storage Co
PNGTS/Maritimes & Northeast
Pony Express Pipeline
Portland Natural Gas PL
Public Service Co of NC
Public Service Co of NM
Questar Pipeline Co
Questar Southern Trails Line
Ram-Powell Pipeline (Shell)
Roadrunner
Rockies Express (Echo Springs Lateral)
Rockies Express (Entrega)
Rockies Express Pipeline
Rocky Mountain Natural Gas Co
Rover Pipeline
Ruby Pipeline LLC
Sabal Trail Pipeline
Sabal Trail Transmission
Sabine LLC
San Diego Gas & Elec Co
Sea Robin Pipeline
Shoshone Pipeline
Sierrita Gas Pipeline
SONAT Exploration Co
South Carolina PL Corp
South Georgia Gas Pipeline Co
Southeast Supply Header Pipeline Co
Southern California Gas Co
Southern Natural Gas Co
Southern Pines Storage Lateral
Southern Star Central Gas PL Co
Southern Union Gas Services (TX)
Southwest Gas Corp
Spirit Offshore Lateral
St Lawrence Gas Co
Stingray Pipeline
Tallgrass Interstate Gas Transmission
Tarpon Gathering System
Tengasco Gas Co
Tennessee Gas Pipeline
Texas Eastern Trans Co
Texas Gas Transmission Co
Texas Intrastate Pipeline Co
The Exploration Co
Trailblazer Pipeline Co
Trans Pecos Pipeline
TransColorado Gas Trans Co
Transcontinental Gas PL
TransOk Pipeline Co
Transwestern Gas Co
Triton Offshore Pipeline System
Trunkline Gas Co
Tuscaloosa Pipeline Co
Tuscarora Pipeline Co
Union Light Heat & Power
USG Pipeline Co
Valley Gas Pipeline Co
Vector Pipeline Co
Venice Gas Gathering Sys
Vermont Gas System
Viking Gas Transmission Co
Viosca Knoll Gathering Company
Virginia Natural Gas Co
West Ohio Gas Co
West Texas Gas
William Deepwater Pipeline
Williston Basin Interstate PL Co
Worsham-Steed Pipeline
Wyoming Interstate PL Co


The add user action is very similar to the change password function. Copy the entire 'change_password' action from the edit function into the 'menu' element.
We need to change the shared constant 'USER_NAME' to type 'raw' because we need to get the value from the form, just like we needed to get the password from the form previously.
The form needs to now have a field for the user to input the new user's name.
When we perform the stored procedure 'DB2AUTH.ADD_USER,' we are using the user name from the form input, not from the row. Therefore, we no longer need to define the parameter that used to fetch the value from the row.
Finally, one extra onMatch condition is added, because there is one extra error message pattern to our stored procedure.


--- layout: post title: One little digit... so much difference date: '2012-03-09T00:00:00+01:00' tags: - ruby - gem - fail tumblr_url: http://aladac.tumblr.com/post/19947476958/one-little-digit-so-much-difference ---
I was writing a simple script which was supposed to dump data from MySQL to a flat file with pipe delimited values.
The output was supposed to be in CP-1250 encoding, but somehow the transcoding failed, stating incorrect conversion from ASCII-8BIT, to UTF-8 then to the desired encoding…
I was surprised, because when I analyzed the output before transcoding it was UTF-8 not ASCII-8BIT (whatever it is).
After googling I learned what I was doing wrong – I was actually using an older gem called mysql and was supposed to be using mysql2 :)


Progress Bar
<mat-progress-bar>
A linear progress indicator should always fill from 0% to 100% and never decrease in value. It should be
represented by bars on the edge of a header or sheet that appear and disappear.
For multiple operations happening in sequence, use the indicator to represent the progress as a whole, and
not each individual operation.


Welcome to Introductory Security!
(With a concentration on RSA encryption)
@author Kimberly Keller
@date July, 2016
Confidentiality
Keeping data and information private.
Accessibility
Allowing data to be accessed by the appropriate parties when called upon.
Integrity
Making sure the data remains unaltered by unauthorized parties
Who Does Web Security Effect?
In short, security effects everyone. However today we're going to focus on how it impacts developers and end users. Everyone today sends sensitive information over the internet on a regular basis, whether it's confidential work information or usernames, passwords, social security numbers, etc. Hopefully when we send this information we're protecting ourselves and being protected by the engineers who build our software.
Some Key Players
- Developers
- Software Architects
- System Administrators
- End Users
History
Encryption, in short, is scrambling data in order to make it difficult to understand.
Cryptography, the study of making things secret, is not only fun but extremely relevant to the modern information age.
RSA Encryption is a specific algorithm for scrambling data. RSA stands for Ron Rivest, Adi Shamir and Leonard Adleman who
publicly declared the method in 1978. It is the most widely used method of encryption and underscores common practices like PGP, SSH, and SSL.
Technical
RSA Encryption is considered asymmetric encryption, which relies on each user having both a public and private key. Asymmetric encryption is considered more secure because it doesn't require the passage of sensitive information, public keys are by definition public and shareable. We'll dive more deeply into how the algorithm works in a moment.
Importance
Why does this matter? To the developer, having a deeper knowledge of the standard encryption methods allows for a more robust understanding of information security. For the end user or day to day person, having a foundational understanding of the most common encryption practice is critical to understanding how sensitive information is (or should be) handled.
A Deeper Look At The Technical
The Lock Problem
Before 1970, encryption was done symmetrically. Meaning a private key was exchanged to encrypt and decrypt messages. The question asymmetric encryption answers is, what if we don't have to share a private key? Instead, we publish a "lock". In 1978 a mathematical model was created to do just this.
One Way Functions
A full mathematical explanation is out of the scope of this lecture, however I do want to touch on the concept of one way functions. This means something that is easy to do in one direction and difficult to do in the opposite direction. For this purpose, I'm going to use a color analogy to explain the process of RSA encryption.
The Color Analogy
The color analogy shows how private information can be shared, encrypted and decrypted, without a third party learning the content of the message, and without sharing the decryption method or key.
Some Key Points
- Private vs. Public "Color" (key)
- Inverse Colors
- Eve is always listening
Encrypt your data, protect yourself!
For more information on public key cryptography, watch the video included. It does a good job with the math section as well as takes credit for the color analogy presented here.
Credits:


---
layout: default
title: Handling Harassment
image:
feature: boston-map.png
---
Attendee Procedure For Handling Harassment
Download Policy as PDF
This procedure has been adopted from the Ada Initiative’s guide titled “Conference anti-harassment/Responding to Reports” and PyCon 2017’s policy.
- Contact either staff personnel Caitlin Gaborow, Guido Stein, Ashley Tardif or Michael Terner (info below). The staff will also be prepared to handle the incident. All of our staff members are informed of the code of conduct policy and guide for handling harassment at the conference. There will be a mandatory staff meeting onsite at the conference when this will be reiterated as well.
- Report the harassment incident (preferably in writing) to Caitlin, Guido, Ashley or Michael - all reports are confidential.
- When reporting the event to staff, try to gather as much information as available, but do not interview people about the incident - Staff will assist you in writing the report/collecting information.
- The important information consists of:
- Identifying information (name) of the participant doing the harassing
- The behavior that was in violation
- The approximate time of the behavior (if different than the time the report
was made)
- The circumstances surrounding the incident
- Other people involved in the incident
The staff is well informed on how to deal with the incident and how to further proceed with the situation.
- If everyone is presently physically safe, staff will involve law enforcement or security only at a victim’s request. If you do feel your safety in jeopardy please do not hesitate to contact local law enforcement by dialing 911. If you do not have a cell phone, you can use any hotel phone or simply ask a staff member.
All reports should be made directly to
- Caitlin Gaborow, Conference Organizer
- Guido Stein, Conference Co-Chair
- Ashley Tardif, Conference Operations Coordinator
- Michael Terner, Conference Chair


CrankyCritic® movie reviews: Mystery Men Rated [PG-13], 100 minutes Starring Hank Azaria, Janeane Garofalo, Greg Kinnear, William H. Macy, Kel Mitchell, Paul Reubens, Geoffrey Rush, Ben Stiller, Wes Studi Screenplay by Neil Cuthbert Based on the comic by Bob Burden Directed by Kinka Usher website: http://www.mysterymen.com
IN SHORT: Inferior Five via Not Brand Ecch!
If it isn't obvious from the X-Men Movie updates on the homepage, Cranky is deeply into comic books. The creative team behind Mystery Men, from Bob Burden (who created the team as part of his Flaming Carrot book) to the folks at Dark Horse (who have a better track record with bringing comics to the bigscreen, and vice versa, than any of the Big Three) have peppered this flick with lots of in-jokes that will be readily apparent to any fanboy. That being said, no knowledge of comic history is necessary to enjoy the world of Champion City and its defender, Captain Amazing (Greg Kinnear).
The Captain has done such a good job protecting his city that the only
bad guys left are bands of two-bit villains who steal dentures out of
the mouths of retirees. Crime is down, as are revenues from products
like Pepsi and Mighty White Toothpaste, whose logos make the Captain's
uniform look like that of a stock car race driver. Only the return of an
evil villain, like the scurrilous Casanova Frankenstein (Geoffrey Rush)
can improve the bottom line so, with the aid of bespectacled billionaire
Lance Hunt (who looks remarkably like Greg Kinnear
If the villains of Champion City are two bit, the remaining superheroes are even less. There's Mr. Furious (Ben Stiller) possessed of an anger and rage that makes him, um, angry. There's The Blue Raja (Hank Azaria), an effeminate British accented good guy whose deadly aim with forks and spoons (no knives -- knives are dangerous and could hurt someone) is less than deadly. He's not really effeminate, by the way, its just part of his superhero act. Last up is The Shoveler (William H. Macy) who wears a catcher's chest protector and has a shovel.
Champion City is in deep trouble.
Turning the superhero genre on its ear yields a flick that is, thematically, visually and aurally delightful.  The Shoveler has a wife and two kids to support (and Mrs. Shoveler has had just about enough). The production design of Champion City is breathtaking. The high tech talk coming out of the mouths of the heroes (neuro-laser-hossenpfeffer-chopper indeed) is dead on loving parody of comic book excess. As in the comics, to save the day, a super-team of heroes must be built. That means open auditions, held in the backyard of The Shoveler's house. What a motley group ...
The remaining superheroes, all third string, include The Bowler (Janeane Garafalo) whose bowling ball contains her dad's skull; The Spleen (Paul Reubens), whose silent but deadly power yields the funniest fart joke of the summer; Invisible Boy (Kel Mitchell) whose invisibility power works only if no one is looking at him; and the mysterious The Sphinx (Wes Studi), whose telekinetic power split guns in two with and who trains our team of misfits with instructional dialog that would have been at home amidst the gobbledygook heard in The Matrix. In this case, it's supposed to be funny. Rounding off the cast is Tom Waits as the good guy weapons designer whose guns won't kill; Eddie Izzard (currently star of an HBO comedy special) and Fugee music star Pras as the murderous bad guys, the Disco Boys. You know they're bad -- they use guns.
Tomake comic heroes work, you've got to play 'em straight. William H. Macy is the center of the team, a DC-style man in a Marvel-style group wracked by self-doubt. Janeane Garofalo, above all the rest, nails the schizophrenic identity shtick that accompanies the super-life. Basically, she still discusses her actions with her dad. See it and believe it.
Mystery Men gently pokes fun at Superman, Batman, the X-Men and at least one teevee SF superhero (telling would spoil the surprise) and is definitely one for us boys. On the downside, this is a popcorn flick that may be too clever for its own good. There's not enough in it to keep you glued to your seats -- Cranky's gut feeling is that Frankenstein just isn't bad enough -- ducking out in the middle won't mean you'll anything vital but, c'mon folks, this kind of cast in this kind of flick is just too tempting to avoid.
Parents to whose kids Kel Mitchell is a superstar (from Nickelodeon's Kenan and Kel series) will find no reason to keep their kids away from the flick, though some of the superhero dialog shtick may confuse 'em.
On average, a first run movie ticket will run you Eight Bucks. Were Cranky able to set his own price to Mystery Men, he would have paid...
$5.00
Dateflick level. Mystery Men is terrific eye candy and a fine popcorn movie if you've got a little boy child locked away inside. There's nothing here that wouldn't work fine on the little screen, which should mean a lower rating on the Cranky scale, but it's summertime and lite is good.
Cast members William H. Macy, Ben Stiller, Janeane Garofalo, Geoffrey Rush and Paul Reubens (formerly known as Pee Wee Herman) all reveal that they know diddle about comic books in their Cranky Critic® StarTalk. A good time was had by all.
Best non-comics in-joke: Real life magician Ricky Jay saying to Captain Amazing: "I'm a publicist, not a magician!"
Cranky Critic® is a Registered Trademark of, and Copyright © by, Chuck Schwartz. All Rights Reserved.
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


Drinking alot of Coffee is one of my Job requirements.
Since I started programming in 2021 after the pandemic, I have provided millions with the information,
inspiration and connections they need to start, grow and manage a successful startup business through my
coding skills.
I am a passionate developer, Mark Liam Abenger,located in Nairobi, Kenya.
Why did I get into PROGRAMMING? Unfortunately, during the pandemic most of the marketing
budget for big multinationals was slashed and there was a subsequent ripple effect in the industry.
Luckily, the company I was working for stormed through, but the pandemic had initiated a peculiar
thought in me: "I need a skill that could weather a storm ".
In the next 2 months I did my research
on coding bootcamps in kenya and came across Moringa.
I talked to my boss about my interests in pursuing this long overdue passion of mine in coding. We
came to an agreement and we parted ways.
Now, here I am, standing tall and proud of the decision to apply because I am now a programmer.
1.Used Python as the core language and CSS for styling
2.Used Html as the core language and CSS for styling
3.Used Html as the core language and CSS for styling
4.Used Html as the core language and CSS for styling
The rewards are yours to keep.


Reflections on Website Design
Today I reflect on what it was like to design this personal website as part of Phase 0 of Dev Bootcamp.
Today I reflect on what it was like to design this personal website as part of Phase 0 of Dev Bootcamp.
Today I discuss why we all need to learn and follow TDD from the start, because you're gonna wish you had it in the end.
Today I compare Ruby and Javascript classes. I delve into how public, private and static versions are made in each.
Today I discuss the very basics of Ruby classes.
Today I discuss the usefulness of Ruby's enumerables' map method.
Today I discuss a simple little safety tip to protect yourself while browsing online using a popular free anti-malware program.
Today I discuss and compare the programming data structures known as arrays and hashes.
The differences between the positioning types in CSS.
Today I'll be blogging a little about the importance of version control.


Reports
switch
statements where the
default
case comes before some other case. This construct is unnecessarily confusing.
Powered by InspectionGadgets


Man climbs onto traffic light in busy Manhattan intersection
by Eyewitness NewsMIDTOWN MANHATTAN (WABC) -- An odd scene unfolded at a busy Midtown intersection as a man perched himself on top of a traffic light.
Video shows the man sitting on the support bar between the two lights high above the intersection of 35th Street and 6th Avenue on Wednesday.
NYPD officers blocked the intersection and used an emergency services truck to climb up and take the man into custody.
He was taken to the hospital and was not charged.


inflections = require('../inflect').inflections
inflections = require('../inflect').inflections
By default, camelize converts strings to UpperCamelCase. If the argument to camelize is set to false then camelize produces lowerCamelCase.
"active_record".camelize() # => "ActiveRecord"
"active_record".camelize(false) # => "activeRecord"
As a rule of thumb you can think of camelize as the inverse of underscore, though there are cases where that does not hold:
"SSLError".underscore().camelize() # => "SslError"
camelize = (lower_case_and_underscored_word, first_letter_in_uppercase = true) ->
rest = lower_case_and_underscored_word.replace /_./g, (val) -> val[1..-1].toUpperCase()
if first_letter_in_uppercase
lower_case_and_underscored_word[0].toUpperCase() + rest[1..-1]
else
lower_case_and_underscored_word[0].toLowerCase() + rest[1..-1]
Makes an underscored, lowercase form from the expression in the string.
"ActiveRecord".underscore() # => "active_record"
As a rule of thumb you can think of underscore as the inverse of camelize, though there are cases where that does not hold:
"SSLError".underscore().camelize() # => "SslError"
underscore = (camel_cased_word) ->
word = camel_cased_word.toString()
word = word.replace(/([A-Z]+)([A-Z][a-z])/g,'$1_$2')
word = word.replace(/([a-z\d])([A-Z])/g,'$1_$2')
word = word.replace(/-/g, '_')
word = word.toLowerCase()
word
dasherize = (underscored_word) ->
underscored_word.replace(/_/g, '-')
Capitalizes all the words and replaces some characters in the string to create a nicer looking title. titleize is meant for creating pretty output.
"man from the boondocks".titleize() # => "Man From The Boondocks"
"x-men: the last stand".titleize() # => "X Men: The Last Stand"
titleize = (word) ->
humanize(underscore(word)).replace /\b('?[a-z])/g, (val) -> capitalize(val)
Converts the first character to uppercase and the remainder to lowercase.
'über'.capitalize() # => "Über"
capitalize = (word) ->
(word[0] || '').toUpperCase() + (word[1..-1] || '').toLowerCase()
Converts the first character to lowercase and leaves the remainder intact.
'über'.capitalize() # => "Über"
decapitalize = (word) ->
(word[0] || '').toLowerCase() + (word[1..-1] || '')
Returns the plural form of the word in the string.
"post".pluralize() # => "posts"
"octopus".pluralize() # => "octopi"
"sheep".pluralize() # => "sheep"
"words".pluralize() # => "words"
"CamelOctopus".pluralize() # => "CamelOctopi"
pluralize = (word) ->
result = word.toString()
if word.length == 0 || inflections().uncountables.indexOf(result.toLowerCase()) != -1
result
else
for plural in inflections().plurals
rule = plural[0]
replacement = plural[1]
if result.search(rule) != -1
result = result.replace(rule, replacement)
break
result
The reverse of pluralize, returns the singular form of a word in a string.
"posts".singularize() # => "post"
"octopi".singularize() # => "octopus"
"sheep".singularize() # => "sheep"
"word".singularize() # => "word"
"CamelOctopi".singularize() # => "CamelOctopus"
singularize = (word) ->
result = word.toString()
uncountable = false
for inflection in inflections().uncountables
if result.search(new RegExp("\\b#{inflection}$", 'i')) != -1
uncountable = true
break
if word.length == 0 || uncountable
result
else
for singular in inflections().singulars
rule = singular[0]
replacement = singular[1]
if result.search(rule) != -1
result = result.replace(rule, replacement)
break
result
Capitalizes the first word and turns underscores into spaces and strips a trailing “_id”, if any. Like titleize, this is meant for creating pretty output.
"employee_salary" # => "Employee salary"
"author_id" # => "Author"
humanize = (lower_case_and_underscored_word) ->
result = lower_case_and_underscored_word.toString()
for human in inflections().humans
rule = human[0]
replacement = human[1]
if result.search(rule) != -1
result = result.replace(rule, replacement)
break
capitalize(result.replace(/_id$/, '').replace(/_/g, ' '))
Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
ordinalize(1) # => "1st"
ordinalize(2) # => "2nd"
ordinalize(1002) # => "1002nd"
ordinalize(1003) # => "1003rd"
ordinalize = (number) ->
number_int = parseInt(number, 10)
if [11..13].indexOf(number_int % 100) != -1
"#{number}th"
else
switch number_int % 10
when 1 then "#{number}st"
when 2 then "#{number}nd"
when 3 then "#{number}rd"
else "#{number}th"
Replaces special characters in a string so that it may be used as part of a ‘pretty’ URL.
parameterize("Donald E. Knuth") # => "donald-e-knuth"
parameterize("Donald E. Knuth", '_') # => "donald_e_knuth"
parameterize = (string, sep = '-') ->
parameterized_string = string.toString()
Turn unwanted chars into the separator
parameterized_string = parameterized_string.replace(/[^a-z0-9\-_]+/gi, sep)
if sep?
No more than one of the separator in a row.
parameterized_string = parameterized_string.replace(new RegExp("#{sep}{2,}", 'g'), sep)
Remove leading/trailing separator.
parameterized_string = parameterized_string.replace(new RegExp("^#{sep}|#{sep}$", 'gi'), '')
parameterized_string.toLowerCase()
exports.camelize = camelize
exports.underscore = underscore
exports.dasherize = dasherize
exports.titleize = titleize
exports.capitalize = capitalize
exports.decapitalize = decapitalize
exports.pluralize = pluralize
exports.singularize = singularize
exports.humanize = humanize
exports.ordinalize = ordinalize
exports.parameterize = parameterize


Home
About
Overview
Quality Policy
Vision & Mission
Gallery
Jewellers
Art
Music
Business
Services
Contact
COMING SOON
Sorry for the inconvenience this website is under construction and will soon be Online..


// Wind speed, current and voltage logging software (to SD memory) using real time clock.
//Software part of the OpenEnergyMonitor.org project
// and designed for V3 power (application at Bath University)
//Author: Suneil Tagore
// Date: 25/2/11
// This sketch logs windspeed, current and voltage
// Implements a real time clock DS1302 using DS1302.h library
// Writes data (including timestamp) to an SD card using SD.h library, comma separated.
// Red LED indicates write operation to SD card
// Green LED indicates it is safe to remove SD card (but be quick! the green LED will time out after a short delay)w
// pushbutton on analog(2) halts program to allow safe SD removal
// wind pulses are counted using an interupt method
/*
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
see .
*/
#include
#include // rtc lib
// Init the DS1302
DS1302 rtc(6, 4, 3);
const int chipSelect = 10; // for SD on nuelectronics
int redLEDpin=7;
int greenLEDpin=9;
int yellowLEDpin =8; // not implemented
int INTERVAL = 10000; // interval at which sampling takes place over the entire loop
double avVoltage, voltage, voltageSum = 0;
double avCurrent, current, currentSum = 0;
double power;
int counter=0;
// calibration
double CURRENT_OFFSET = 0.5; // the hall probe is offset from zero amps.
double CURRENT_SCALER = 0.133; //use multimeter to verify.
double VOLTAGE_SCALER = 0.055932203; // R1 = 3.3.K, R2 = 56K, 3.3/59 = 0.055932203. measure accurately with multimeter!
double VOLTS_PER_DIV = 0.004882813; // 5/1024 (or is it 1023?)
double WIND_CALIB = (2.5)*(0.44704); // 2.5 mph per Hz, and mph to m/s
double windPulses;
double windSpeed;
unsigned long lastMillis;
void setup(){
Serial.begin(9600);
// ------------------SD card initialise ----------------------------------
Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
// don't do anything more:
return;
}
Serial.println("card initialized.");
// RTC stuff ---------------------------
// Set the clock to run-mode, and disable the write protection
rtc.halt(false);
rtc.writeProtect(false);
// Setup Serial connection
Serial.begin(9600);
// The following lines can be commented out to use the values already stored in the DS1302
//rtc.setDOW(SATURDAY); // Set Day-of-Week to FRIDAY
//rtc.setTime(15, 00, 0); // Set the time to 12:00:00 (24hr format)
//rtc.setDate(26, 2, 2011); // Set the date to August
// ---------------------------------------
// ----- LED pins
pinMode(redLEDpin, OUTPUT); // SD writing warning
pinMode(greenLEDpin, OUTPUT); // safe SD card removal
pinMode(yellowLEDpin, OUTPUT); // windspeed pulses
// do this last in setup, so that pulsecounts are properly initialised with timer millis..
attachInterrupt(0, pulseCount, RISING); // interupt in digital pin2
lastMillis = millis();
}
void loop()
{
if(analogRead(2) > 500) // if.. to halt program to allow safe SD card removal
{
//Serial.println(analogRead(2));
digitalWrite(greenLEDpin, HIGH);
Serial.println("halted");
delay(10000);
//Serial.println(analogRead(2));
digitalWrite(greenLEDpin, LOW);
//reset all values:
avCurrent =0;
currentSum =0;
avVoltage =0;
voltageSum =0;
counter =1; // reset
lastMillis = millis(); // reset
windPulses = 0; //reset
}
analogRead(0); // creates a delay to prepare analog(0) channel
if((millis() - lastMillis) > INTERVAL){
// do wind calc first so that interupt value does not change..
windSpeed = (windPulses/(INTERVAL/1000))*WIND_CALIB; // in metres per second
//Serial.println(windSpeed);
//Serial.println("here");
//Serial.print(" ");
avCurrent = ((avCurrent* VOLTS_PER_DIV) - CURRENT_OFFSET )/ CURRENT_SCALER; // calibrate
//Serial.print(avCurrent);
//Serial.print(" ");
avVoltage = avVoltage * VOLTAGE_SCALER; // calibration
//Serial.print(avVoltage);
//Serial.print(" ");
power = avCurrent*avVoltage;
//Serial.println(power);
// create datastring and write to SD card..
String dataString = ""; // reset string
//dataString += rtc.getDOWStr(); // day of week not necessary
//dataString += ",";
dataString += rtc.getDateStr();
dataString += ",";
dataString += rtc.getTimeStr();
dataString += ",";
//dataString += String(int(windSpeed)); // String() does not work in doubles it seems, will int truncate?
// .. therefore write doubles directly to file...
// file automation, abandoned method due to SD file coruption.. try to implement at later date..
//String dateString;
//dateString = rtc.getDateStr();
//char this_char[dateString.length() + 1];
//dateString.toCharArray(this_char, sizeof(this_char));
//int my_integer_data = atoi(this_char);
//int filenameSize = sizeof(this_char) -1; // -1 or -2 for less dots..
// char filename[filenameSize];
// int skipdot =0;
//for(int x; x


Outsourced Services
Contracted Operations
Project Planning & Management
Program Implementation
Temporary Personnel
Contracting Positions
HW/SW Purchasing & Delivery
Product Support & Services


I/O
Arc has a large variety of I/O operations that support file, string, and network I/O. Because Arc's I/O system is based on MzScheme, the MzScheme I/O documentation provides useful background.
Arc's I/O system is built in layers. The foundation provides basic operations. On top of this, more functional operations are constructed. The w/
(with/) series of operations are generally the most convenient.
One main I/O abstraction in Arc is the port: an input port produces bytes and an output port consumes bytes. A port may be created by opening a file or socket. In addition, Arc supports string I/O, where a string can provide data as an input port, or can receive data as an output port.
For input, Arc provides support to read a byte, character, line, or Scheme S-expression. (Because Arc inherit's MzScheme's Unicode support, one Unicode character may involve more than one byte.)
Some of Arc's input operations indicate end-of-file through a user-specified eof value. This can be a symbol such as 'eof
or nil
.
Arc's read methods take a variety of arguments: some require a port, some default to stdin
, and some allow a string as input. Some take an arbitrary number of body statements, while some take a "thunk", a function to evaluate.
Arc provides multiple operations for output. The prn
procedure is useful for general-purpose printing, as well as for debugging. By wrapping it with w/stdout
, the output can be directed to a file or string.
Arc supports formatted output, with very limited control over formatting. The prf
operation uses a format string, which can contain two types of formatting directives. A "#" followed by a form causes the form to be evaluated. A "~" followed by an ignored character causes the directive to be replaced by the next argument. For example:
arc> (let x 42 (prf "#(+ 1 1) ~x #x\n" 111))
2 111 42
""
One convenient pattern in Arc is to read and write S-expressions to avoid encoding and parsing data. Multiple operations support reading S-expressions, either individually or an entire set at once, from multiple sources. If the syntactic correctness of the input is uncertain, saferead
can be used.
Arc also includes multiple string I/O operations that allow a string to be used for input or output. The simplest operations are fromstring
and tostring
, for input or output respectively. See MzScheme String Ports for background on String Port I/O.
Input
|
readb [input-port]
Reads a byte from the input-port (or default of
stdin). Returns nil on end-of-file.
|
>(readb (pipe-from "echo hello"))
104
|
|
readc [input-port]
Reads a character from the input-port (or default of
stdin). Returns nil on end-of-file.
|
>(readc (pipe-from "echo ©"))
#\©
|
|
peekc input-port
Peeks at the next character from the input port, but
leaves the character for future reads. It
uses stdin if the argument is nil. It returns the character, or nil for
end-of-file.
|
>(peekc (pipe-from "echo hello"))
#\h
|
|
readline [input-port]
Reads a line from the specified port or stdin. The line is read up to a newline, nil, or eof. An initial newline does not terminate the input and appears in the output. A trailing newline is not included in the returned value.
|
>(w/instring ins "\n\na\nc\n\nd"
(whiler l (readline ins) nil (prn "{" l "}")))
{
}
{a}
{c}
{
d}
nil
|
|
sread input-port eof
Reads a S-expression from the input port. Returns eof on end-of-file.
|
>(sread (pipe-from "echo '(1 2) (3)'") "junk")
(1 2)
|
|
read [input-source [eof]]
Reads a S-expression from the input-source, which can be either a string or an input-port. If the end of file is reached, nil is returned or the specified eof value.
|
>(read "(+ 1 1)(foo bar)")
(+ 1 1)
>(w/instring ins "(foo 42)" (read ins))
(foo 42)
>(read "" 'eof)
eof
|
|
readstring1 string [eof]
Reads a S-expression from the string. This is the same as read , except only handles a string.
|
>(readstring1 "(+ 1 1)")
(+ 1 1)
|
|
saferead input-source
Reads a S-expression from the input-source, which can be either a string or an input-port. If the end of file is reached, nil is returned or the specified eof value. If an error is encountered in the input, returns nil.
|
>(saferead "1 + 1")
1
>(saferead "###")
nil
|
|
readall input-source [eof]
Reads S-expressions from the input-source, which can be either a string or an input-port. Returns a list of the S-expressions. If the end of file is reached, nil is returned or the eof value if specified.
|
>(w/instring ins "(+ 1 1)abc (foo)" (readall ins))
((+ 1 1) abc (foo))
>(readall "[_]")
((fn (_) (_)))
|
|
load path
Loads the file of Arc code into the REPL environment.
|
>(load "strings.arc")
nil
|
Output
|
disp [arg [output-port]]
Displays the argument on the output-port (or
current-output-port) using MzScheme's display procedure. Returns nil.
|
>(disp '(1 2))
(1 2)
nil
>(disp "abc")
abc
nil
>(disp #\a)
a
nil
>(disp "a\nb")
a
b
nil
|
write [arg [output-port]]
Writes the argument to the output-port (or
current-output-port). Returns nil. The write and disp operations are slightly different: write quotes strings and characters, while disp displays them. See the
MzScheme
Default
Printer documentation for details.
|
>(write "abc")
"abc"
nil
>(write #\a)
#\a
nil
>(write "a\nb")
"a\nb"
nil
|
|
writeb int [output-port]
Writes the byte to the output-port (or
default of current-output-port).
|
>(writeb 65)
A
65
|
|
writec char [output-port]
Writes the character to the output-port (or
default of current-output-port).
|
>(writec #\日)
日
#\日
|
|
pr [arg ...]
Prints arguments using disp . Returns the first argument.
|
>(pr 1 "a")
1a
1
|
|
prn [arg ...]
Prints arguments followed by a newline.
|
>(prn 1 "a")
1a
1
|
|
prall elts [initial-string [separator-string]]
Prints each element of list elts. The initial-string is printed first. The elements are separated by separator-string. Returns elts .
|
>(prall '(1 2 3))
1, 2, 3
(1 2 3)
>(prall '(1 2 3) "Value: " "-")
Value: 1-2-3
(1 2 3)
|
|
prs [arg ...]
Prints the arguments, separated by a space. Returns the arguments as a list.
|
>(prs 1 2 3)
1 2 3
(1 2 3)
|
|
prf str [arg ...]
Prints args using the format string.
|
>(let hi "hello" (prf "#hi #(+ 1 2)"))
hello 3
""
>(prf "Num ~a and ~~" 1 2)
Num 1 and 2
"Num "
|
|
out expr
Prints what expr prints. expr is evaluated at macro expansion time. New in arc3.
|
>(out (pr 42))
42
"42"
|
|
parse-format str
Parses a format string. An internal helper for prf .
|
|
|
ero [arg ...]
Writes the args to stderr. Returns the first arg.
|
>(ero "This appears on stderr")
"This appears on stderr"
|
|
warn msg [arg ...]
Displays warning msg, followed by the arguments.
|
>(warn "Problem" '(1 2) 3)
Warning: Problem. (1 2) 3
nil
|
File I/O
|
readfile filename
Reads a file containing Lisp forms. Returns a list of the forms.
|
>(readfile "foo.arc")
Error: open-input-file: cannot open input file
path: /path
/to/doc/foo.arc
system error: No such file or directory; e
rrno=2
|
|
readfile1 filename
Reads a single Lisp form from the specified file.
|
>(readfile1 "foo.arc")
Error: open-input-file: cannot open input file
path: /path
/to/doc/foo.arc
system error: No such file or directory; e
rrno=2
|
|
writefile obj filename
Writes obj to the specified file. The contents are first written to filename.tmp, and then that is moved to filename.
|
>(writefile '(1 2) "bar.arc")
(1 2)
|
|
infile filename ['binary | 'text]
Opens the specified path for
reading. By default, the file is opened in binary mode, and bytes are
returned as read from the file. In text mode, return and linefeed bytes are
filtered in a platform-specific way. (On Windows, return followed by
linefeed is filtered to a single linefeed.)
|
>(infile "foo.arc")
Error: open-input-file: cannot open input file
path: /path
/to/doc/foo.arc
system error: No such file or directory; e
rrno=2
|
|
w/infile var filename [body ...]
Opens filename for reading with infile, assigns the input-port to var, executes body, and closes the file.
|
>(w/infile inf "foo.arc" (read inf))
Error: open-input-file: cannot open input file
path: /path
/to/doc/foo.arc
system error: No such file or directory; e
rrno=2
|
|
outfile filename ['append]
Opens the specified path for writing. By
default, the file is truncated if it already exists. Returns an
output-port. Arc supports only 'text mode for outfile.
|
>(outfile "/tmp/junk" 'append)
#<output-port:/tmp/junk>
|
|
w/outfile var filename [body ...]
Opens filename for writing with outfile, assigns the output-port to var, executes body, and closes the file.
|
>(w/outfile outf "bar.arc" (w/stdout outf (prn "Hello")))
"Hello"
|
|
w/appendfile var filename [body ...]
Opens filename for appending with outfile, assigns the output-port to var, executes body, and closes the file.
|
>(w/appendfile af "bar.arc" w/stdout af (prn "Hello"))
Hello
"Hello"
|
|
close port [...]
Closes a port or ports. In arc0, close took a single argument only.
|
>(close (outfile "/tmp/junk"))
nil
|
|
pipe-from command
Executes command in the underlying OS. Then opens
an input-port to the results. Note that this is not a genuine pipe as the command completes before the results can be read.
|
>(readline (pipe-from "echo hello"))
"hello"
|
|
flushout
Flushes output. New in arc3.
|
>(flushout)
t
|
Disk variables
|
diskvar var file
Creates a variable that will be loaded from file and stored in file. If file exists, var is initialzed from file. New in arc3.
|
>(diskvar foo "file.txt")
nil
|
|
disktable var file
Creates a table variable that will be loaded from file and stored in file. New in arc3.
|
>(disktable bar "file.txt")
nil
|
|
todisk var [expr]
Writes var to disk, optionally setting it to expr first. New in arc3.
|
>(todisk bar)
Error: Function call on inappropriate object nil (#
<procedure: bar>)
|
|
fromdisk var file init load save
If var is not bound, var is initialized either by calling load function on file or using init. The save function is saved for later use. Internal function. New in arc3.
|
|
stdin, stdout, and stderr
|
stdin
stdin: returns the input-port stdin
|
>(stdin)
#<input-port:stdin>
|
|
stdout
current-output-port: returns the output-port stdout
|
>(stdout)
#<output-port:string>
|
|
stderr
current-error-port: returns the output-port stderr
|
>(stderr)
#<output-port:stderr>
>(write "Error message" (stderr))
nil
|
|
call-w/stdin input-port thunk
Sets stdin
to the specified port and then executes the thunk.
|
>(call-w/stdin (instring "Hello") readline)
"Hello"
|
|
w/stdin input-port [body ...]
Sets stdin to the specified port and then executes the body.
|
>(w/instring ins "Hello" (w/stdin ins (readline)))
"Hello"
|
|
call-w/stdout output-port thunk
Calls thunk, setting stdin
to the specified port.
|
>(let sop (outstring)
(call-w/stdout sop (fn () (prn '(1 2))))
(inside sop))
"(1 2)\n"
|
|
w/stdout output-port [body ...]
Executes the body port with stdout redirected to the output-port. This is a wrapper around call-w/stdout.
|
>(let sop (outstring)
(w/stdout sop (prn '(1 2)))
(inside sop))
"(1 2)\n"
|
String Port I/O
|
instring string [name]
Creates an input port to read UTF-8 bytes from the
string. This is MzScheme's open-input-string.
|
>(readline (instring "hello"))
"hello"
|
|
w/instring var str [body ...]
Creates an string input-port from str with instring, assigns it to var, executes body, and then closes the input port.
|
>(w/instring ins "(+ 1 1)" (read ins))
(+ 1 1)
|
|
fromstring str [body ...]
Executes the body, using the contents of str as stdin.
|
>(fromstring "(+ 1 1)" (read))
(+ 1 1)
|
|
outstring [name]
Creates an output-port that accumulates the output
into a byte string. The string can be retrieved with inside. This is
MzScheme's open-output-string.
|
>(outstring)
#<output-port:string>
|
|
inside string-output-port
Returns (as a string) the bytes accumulated
in a string-output-port generated by outstring. This is MzScheme's get-output-string.
|
>(let sop (outstring) (write "hello" sop) (inside sop))
"\"hello\""
|
|
w/outstring var [body ...]
Creates a string output-port with outstring, assigns it to var, and executes body.
|
>(w/outstring os (prn "hi") (inside os))
hi
""
|
|
tostring [body ...]
Executes the body. Any output that was sent to stdout is captured and returned as a string.
|
>(tostring (prn "hello") (prn "world"))
"hello\nworld\n"
|
Copyright 2008 Ken Shirriff.


Screamer.js is a Vanilla Javascript plugin to provide simple yet fully customisable web notifications using Web Notifications API.
Click on the buttons to call a Notification.


My website
- Home
- About Us
- Gallery
- Contact Us
Working
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use , you need to be sure there isn't anything embarrassing hidden


Molecule Property Prediction¶
This page contains benchmarks of popular property prediction models.
We consider both vanilla random split and scaffold-based random split for molecule datasets. The split for train/validation/test sets is 80%:10%:10%. For each model, we evaluate it with 5 random splits and report the mean and the deviation of the performance. We report MAE and R2 metrics for regression datasets, AUROC and AURPC metrics for binary classification datasets.
For datasets containing a lot of tasks, only the first 16 tasks are showed here due to space limitations.


Name Type
For some resources, you can specify a custom name. By default, AWS CloudFormation
generates a unique
physical ID to name a resource. For example, AWS CloudFormation might name an Amazon
S3 bucket with the
following physical ID stack123123123123-s3bucket-abcdefghijk1
. With custom names,
you can specify a name that's easier to read and identify, such as
production-app-logs
or business-metrics
.
Resource names must be unique across all of your active stacks. If you reuse templates to create multiple stacks, you must change or remove custom names from your template. If you don't specify a name, AWS CloudFormation generates a unique physical ID to name the resource. Names must begin with a letter; contain only ASCII letters, digits, and hyphens; and not end with a hyphen or contain two consecutive hyphens.
Also, do not manage stack resources outside of AWS CloudFormation. For example, if you rename a resource that's part of a stack without using AWS CloudFormation, you might get an error any time you try to update or delete that stack.
Important
You can't perform an update that causes a custom-named resource to be replaced. If you must replace the resource, specify a new name.
Example
If you want to use a custom name, specify a name property for that resource in your
AWS CloudFormation template. Each resource that supports custom names has its own
property that you specify. For example, to name an DynamoDB table, you use the TableName
property, as shown in the following sample:
JSON
"myDynamoDBTable" : { "Type" : "AWS::DynamoDB::Table", "Properties" : { "KeySchema" : { "HashKeyElement": { "AttributeName" : "AttributeName1", "AttributeType" : "S" }, "RangeKeyElement" : { "AttributeName" : "AttributeName2", "AttributeType" : "N" } }, "ProvisionedThroughput" : { "ReadCapacityUnits" : "5", "WriteCapacityUnits" : "10" }, "TableName" : "SampleTable" } }
YAML
myDynamoDBTable: Type: AWS::DynamoDB::Table Properties: KeySchema: HashKeyElement: AttributeName: "AttributeName1" AttributeType: "S" RangeKeyElement: AttributeName: "AttributeName2" AttributeType: "N" ProvisionedThroughput: ReadCapacityUnits: "5" WriteCapacityUnits: "10" TableName: "SampleTable"
Supported Resources
The following resource types support custom names:


I spent a good chunk of Friday drinking at the Cambridge Innovation Center attending the Boston Simulcast of the Startup Lessons Learned Conference (#sllc) Oh, I mean drinking from the proverbial firehose.
While every talk was pretty good, I am first going to summarize those from which I learnt the most (in the order in which they appeared in the conference). You may also want to check out the list of my tweets from the conference. This is Part of 1 of the Lessons that I learned from the conference. (Update : Part 2 never materialized because I was busy “getting out of the building” and building awesome scanner software that people are willing to pay fo)
- **Kent Beck on **To Agility and Beyond: Kent made a case that the ”Build” -> “Measure” -> “Learn” loop is actually backwards and that it ought to be “Learn” -> “Measure” -> “Build” or put more elaborately, it is to say :
-
Make an assumption
-
Identify how you will validate it, and
-
Build something to validate it.But as Ash Maurya comments on Kent’s blog post, I think the loop is just as fine, depending on your definition of “Build” (Build can be something as small as a dummy landing page or a mockup). The larger takeaway for me was how Kent expanded the Agile Manifesto to Customer Development. Specifically, these extension points were the most interesting to me.
[table id=1 /]
And finally, Kent highlighted that Good engineering is not the same as Good Startup Engineering. Good Startup engineering involves making the transitions from “hack” mode to “scale” mode to “optimize” mode, transitions which define the success of a startup.
-
Ash Maurya on **Continuous Deployment: I was originally amazed when I first read about Eric Reis mention 50 builds a day. **My most important takeaway from this was that it is not necessary to think of continuous deployment as a mega project. In fact, that is against the spirit of being lean. Start somewhere meaningful, and keep chipping at it.
-
IMVU Team on Scaling Customer Development : This was the most informative talk of the conference. It was great to get insights into a how a moderately big-size company does Customer development and if the concept Scales. Well, it does! But you have to watch for some traps.
-
Too much emphasis on customer facing changes will likely increase technical debt: I can definitely related to this. This is precisely while we have instituted a “Kaizen Sprint” at OfficeDrop. The Kaizen Sprint is a short sprint at the end of every 3 sprints, with the goal of reducing the technical debt accumulated during the prior sprints.
-
“Big bet” projects could become next to impossible and a missed opportunity : Yep. When your “radar” is defined by two sprints ahead and you are constantly thinking “Minimum Viable Product”, you absolutely run the risk of doing this. One way to mitigate the effect of such narrow/sharp focus is to institute “hack weeks” (or the Atlassian-inspired variation - FedEx Days that we do at OfficeDrop). Developers can work on whatever they want for that time period and at the end of that, the Product Owner decides on incorporating it back in the product or adds it to the backlog.[Update : Thanks @bdurrett for links to the slides and video from the conference]
- **Eric Reis’ chat with Randy Komisar : **This was the highlight of the conference for me. Randy’s “sage-advice” was that once a startup gets funded, the business plan goes to the trash and gets replaced by a Business Dashboard. No, there is no template for that Dashboard, because that would then be relegated to the same usefulness as the plan. Fundamentally, the dashboard culturally represents your company, is relevant to your industry _AND most importantly, _is helpful to you to provide a sense for where the company is headed. Here are the key components of what should be in a Dashboard
-
Your “leap-of-faith” questions: These are the fundamental questions that will determine if your product will succeed. For example, for the Sony Walkman, the question was whether people would stick in headsets in a subway, rather than talk to other people.
-
What you measure to track those questions: These would include the typical vanity metrics, but also those that are specific to your product / business
-
What are your alternatives if you don’t track against those metrics : This basically forces you to ask the question of “Do we pivot”?
I still have a ton of goodness to write about, including wicked cool stories about Aardvark, KISSMetrics, DropBox and an inspirational talk by Steve Blank. Some teaser questions for you until then (one easy, one not-so). Do you know who founded GM? Do you know who was the rockstar CEO of GM in the early 20th century?


Building a shared approval frontend in XPages
The saying goes: " God would not have been able to create the world in 7 days, if there would have been an installed base to take care of". As much as we wish to have divine powers, we need to make with less and look after an installed base. Point in case: You have a set of approval applications in classic Notes client code, like: Travel, Leave, Expenses, Gifts, Training, BoM changes etc. You are challenged to provide a web and/or mobile interface for them.
 To do this successful, you need to define your scope clearly. In the rest of the article I will work with the following assumptions, if they don't fit your situation, adjust your plan:
In your existing applications the two are stored together (and will stay like that), but you need to extract the flow data to your new approvalCentral application. On the back of a napkin you draw this sequence:
(Image created with JS Sequence Diagrams and postprocessed with InkScape)
The green part of the application exists, the first question is: how to design the submission. There are a number of options you could choose from:
Using this class you can generate the WSDL by pointing to
Using a SOAP client, you can start testing that interface. When you look at the skeleton API you will see a notable absence of specific data for that request. I was thinking quite hard if the specific data should be included and if yes in what format. In conclusion I opted against it to keep the interface lean. Also the set of potential decisions (Yes,No,Try again etc.) is something I'd rather delegate to a configuration document. This will allow to gradually move the whole flow into the approval application.
The callback location would, for a Notes application, contain the notes://... URL, so
The callback can later be used to write back values into the application document. Some planning to get that right (and some facade and factories) is required. Another consideration, once your code is working, is caching. Should you pull the data from the applications live on request or pull them when you get the request. Until your application is running well I'd opt for live pulling - unless the access to the servers is slow.
Your next step: pick a UI layout
Considering your options you have to decide between options:
- Dump the applications and rebuild them on a new platform. Hope that it will take long enough, so nobody will ask you to migrate any of the existing data
- Enable them one-by-one
- Hire Redpill to do an asymmetric modernization
- Build a lateral approval screen across your applications and leave the full web enablement for later
This leaves you with #4. To do this successful, you need to define your scope clearly. In the rest of the article I will work with the following assumptions, if they don't fit your situation, adjust your plan:
- The goal is to provide the decision making screen only, not a complete workflow engine (it could evolve to that)
- Request submission happens in the existing application, providing a new interface for that is outside the current scope
- The flow logic (how many approvers per level etc.) is determined on submission by the original application
- Someone from a different department indicated interest to use the approval screen from a complete different system (that is the "scope creep" that happens in any project)
In your existing applications the two are stored together (and will stay like that), but you need to extract the flow data to your new approvalCentral application. On the back of a napkin you draw this sequence:
(Image created with JS Sequence Diagrams and postprocessed with InkScape)
The green part of the application exists, the first question is: how to design the submission. There are a number of options you could choose from:
- Have the Approval Central application poll participating applications on schedule. That option is least efficient, but might be your only choice if you can't touch the existing apps at all (happens more often than you think, when
admins are paranoidpolicies are set very cautious - Have each application create a flow document directly in the workflow central application. You could use a inherited LotusScript library for that. While that might have been the prefered choice a decade ago, it has two problems: first you limit your participating applications to Notes only (and there are other applications with decision requirements) and you would expose the inner workings of your application prematurely
- Use a web service interface to implement Contract first development. While REST is the current IT fashion, you pick SOAP. The simple reason: LotusScript can talk SOAP quite well via the Webservice consumer design element, while REST would require your notification code being written in Java. So a SOAP service it is
Option Public
Option Declare
Public Class ApprovalRequest
public System As String
Public CallbackLocation As String
Public Title As String
Public Requestor As String
End Class
Public Class ApprovalSubmission
Public Function submitForApproval(request As ApprovalRequest) As String
Dim s As New NotesSession
Dim db As NotesDatabase
Dim doc As NotesDocument
submitForApproval = "OK"
Set db = s.Currentdatabase
Set doc = db.Createdocument()
call doc.Replaceitemvalue("Form", "approvalRequest" )
Call doc.Replaceitemvalue("System", request.System)
Call doc.Replaceitemvalue("Title", request.Title)
Call doc.Replaceitemvalue("CallbackLocation", request.CallbackLocation )
Call doc.Replaceitemvalue("Created", now)
Call doc.Save(true, true)
End Function
End Class
Using this class you can generate the WSDL by pointing to
ApprovalSubmission
as PortType class. The resulting WSDL looks like this:
<?xml version="1.0" encoding="UTF-8"?>
<definitions targetNamespace="urn:DefaultNamespace"
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:apachesoap="http://xml.apache.org/xml-soap"
xmlns:impl="urn:DefaultNamespace" xmlns:intf="urn:DefaultNamespace"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<wsdl:types>
<schema targetNamespace="urn:DefaultNamespace" xmlns="http://www.w3.org/2001/XMLSchema">
<complexType name="APPROVALREQUEST">
<sequence>
<element name="SYSTEM" type="xsd:string"/>
<element name="CALLBACKLOCATION" type="xsd:string"/>
<element name="TITLE" type="xsd:string"/>
<element name="REQUESTOR" type="xsd:string"/>
</sequence>
</complexType>
<element name="REQUEST" type="impl:APPROVALREQUEST"/>
<element name="SUBMITFORAPPROVALReturn" type="xsd:string"/>
</schema>
</wsdl:types>
<message name="SUBMITFORAPPROVALRequest">
<part element="impl:REQUEST" name="REQUEST"/>
</message>
<message name="SUBMITFORAPPROVALResponse">
<part element="impl:SUBMITFORAPPROVALReturn" name="SUBMITFORAPPROVALReturn"/>
</message>
<portType name="ApprovalSubmission">
<operation name="SUBMITFORAPPROVAL">
<input message="impl:SUBMITFORAPPROVALRequest" name="SUBMITFORAPPROVALRequest"/>
<output message="impl:SUBMITFORAPPROVALResponse" name="SUBMITFORAPPROVALResponse"/>
</operation>
</portType>
<binding name="DominoSoapBinding" type="impl:ApprovalSubmission">
<wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="SUBMITFORAPPROVAL">
<wsdlsoap:operation soapAction="SUBMITFORAPPROVAL"/>
<input name="SUBMITFORAPPROVALRequest">
<wsdlsoap:body use="literal"/>
</input>
<output name="SUBMITFORAPPROVALResponse">
<wsdlsoap:body use="literal"/>
</output>
</operation>
</binding>
<service name="ApprovalSubmissionService">
<port binding="impl:DominoSoapBinding" name="Domino">
<wsdlsoap:address location="http://localhost"/>
</port>
</service>
</definitions>
Using a SOAP client, you can start testing that interface. When you look at the skeleton API you will see a notable absence of specific data for that request. I was thinking quite hard if the specific data should be included and if yes in what format. In conclusion I opted against it to keep the interface lean. Also the set of potential decisions (Yes,No,Try again etc.) is something I'd rather delegate to a configuration document. This will allow to gradually move the whole flow into the approval application.
The callback location would, for a Notes application, contain the notes://... URL, so
session.resolve(CallbackLocation)
will give us a handle on the document. Using our newly acquired {{Mustache}} skills, we can call back and pull information out as HTML blob as needed. You might want to pull different information based on the (size) capabilities of your target device.
The callback can later be used to write back values into the application document. Some planning to get that right (and some facade and factories) is required. Another consideration, once your code is working, is caching. Should you pull the data from the applications live on request or pull them when you get the request. Until your application is running well I'd opt for live pulling - unless the access to the servers is slow.
Your next step: pick a UI layout
Posted by Stephan H Wissel on 17 November 2014 | Comments (1) | categories: XPages


Company
Join the team. Make a difference.
Cosmiqo is a humble start-up that creates innovative technology simply to make people smile more. We are always nice to sentient beings and place ethics at the core of our values. Engineers at heart, the team is always looking out for unique ways to enhance the quality of life.
There are some pretty fun and pioneering projects up in the pipeline. From sensor-fusion platforms to geospatial analytics, we are in a position to meddle around with and develop some mind-numbing applications.
If you resonated while reading this, you, like us, would never have to work a day in your life (Confucius was a smart man) and do consider joining us.
Full time / Intern
Make people happier through finely-tuned systems
Full time / Intern
Make people happier through creative use of technology
Intern
Make people happier through compelling, elegant, pleasurable and sophisticated end-to-end user experience solutions


Numbers 8:14
Thus shalt thou separate the Levites from among the children of Israel: and the Levites shall be mine.


---
layout: archive
title: Coin Collector
type: page
image:
feature:
---
Use the arrow keys to move. Press up or spacebar to jump
After the apex of your jump, press up or spacebar again to perform a double jump!
Development
If you are interested in learning about the development of Coin Collector, I wrote a four-part series on my blog describing various aspects of the game.
- Part 1 - Architecture: This post describes how I constructed the underlying structure of Coin Collector. It goes into detail about why gameplay loops and browser architecture are fundamentally different and how I went about solving this problem.
- Part 2 - Terrain Generation: I wanted this game to have procedurally generated terrain that would create a unique landscape for every playthrough. This post talks about how the landscape is constructed and what restrictions are in place to create a challenging yet traversable landscape.
- Part 3 - Collision Detection: What would this game be without a character jumping around and interacting with the environment? I take some time here to explain how the character and environment are represented within the code and how the game calculates collisions between the two.
- Part 4 - Animations: Animations provide those final details that make a game come to life! This post delves into hit boxes vs. animation images and how the game state determines which animation frame needs to play at that specific moment in time.