I am opposed to the $125M URI wants for a new engineering campus. It was only a few years ago that the university wanted to cease being a state school so they would not be under state imposed regulations and their concomitant costs. And yet now they want to be a state school so that they can get $125M from the taxpayers. When URI figures out what it wants its relationship with the people of RI to be then perhaps we can consider supporting this expenditure.
Digital layout comment
A comment on Video: Why eBook Text Layout is Terrible: The problem stems from using visual design features that were designed and refined for a fixed content, and a fixed size page and/or double page spread. There are examples today that are taking the steps needed to design a new visual + dynamic language for documents. When these become more broadly adopted I don't see us missing the widows and orphans.
Disable Chrome's print dialog box
Note to self ... For Mac Chrome users that don't want Chrome's print dialog box you can disable it from the command line using
defaults write com.google.Chrome DisablePrintPreview -boolean true
When the organization can consistently repeat the success ...
When I read headlines like "Building a Trading Platform in 6 Weeks in an Organization That Would Really Rather We Didn't" I think "So what? Anyone or any small team with sufficient domain knowledge, technical skills, and tools could can do that." A one time success is only that -- a one time success. When the organization, and not a specific person or specific team, can consistently repeat the success then tell me about it.
The Danes were victorious over the Normans this Wednesday
The Danes were victorious over the Normans this Wednesday. The Normans and Danes were slated for a final confrontation
The Dane's warlord (aka Cloudbeard, Kim, &, in spirit, Leo) directed a unit of hearthguard with all favorable dice on the battleboard to take down the Norman warlord. There were tense moments of rule reading by the Normans with intent on unhinging the Dane's psyche. When rules were read and positions measured the dice were gathered -- 12 dice for hearthguard and the 5 for the warlord -- and were rolled. The warlord was hit 5 times and now needed 4 saving throws to stay on the field of battle. Only one hit was countered. The Norman warlord, majestic on his white horse let go his shield, glowered at the unbelievers, and fell to ground dead.
An Observer pattern implementation and illiterate programming
This posting is an experiment in documenting Java code using (in my case) illiterate programming. The Java source code is at The Observer Pattern and the Perl code that converted the Java code is at Simpleminded Java + Javadoc to HTML Converter.
The Observer pattern is used to create a relationship between two objects. The relationship is usually unidirectional with the observer waiting for notices from the observed. The relationships is a loose one as the observed only needs to know of the interest of the observer and the observer only needs to know of the set of and ordering of notice the observed will send. A downside of this looseness is that all notices pass through a single observer method for further dispatching.
The Observation class is only used to group all the related interfaces and classes into one file. In a typical development environment each interface and class would be in its own file.
The Observable is the object that is being watched. As changes are prepared and then made the observable will send consent and information notices to the observers. The notices are normally specialized classes that hold some context about the change. For example, if the notice concerns the addition of new inventory to the warehouse then the notice's class could have a method for enumerating the new inventory.
If it is necessary for the observable to have approval before making a change then a consent notification is sent to the observers. Each observer will be notified and if any observer opposes the change then it must return false. The current thread will be used to notify the observers and so all the observed must wait for all observers to consent.
An information notification is normally sent after a change. Since the change has already occurred the notices are typically sent asynchronously by a background thread. The order of the notices is preserved, however.
The observer is the object that is notified by the observable. There is no typed relationship beyond the Observable and Observer classes. As mentioned earlier, the notices are usually of specialized classes where each notice instance holds data relevant to the change.
A registry is the means of establishing the relationship between the observable and the observer. This interface is distinct from Observable as it is sometimes useful to indirectly register an observer via, for example, a registrar.
The order of the observers is undefined.
Adds the observer to the set of observers. Returns true if the observer was added.
Removes the observer from the set of observers. Returns true if the observer was among the observers and was removed.
There is often very little difference between implementations of Observable and Registry and so this base implementation can be widely employed by any class that wants to be observed.
When extending this class make sure to document the set of notices, their consent or information role, and what is their ordering.
The management of the set of observers needs to be thread-safe. The set is expected to be mostly stable over the life of the observed and so copy-on-write semantics is appropriate here.
Information notification notices will be sent by a background thread. A blocking queue will be used to coordinate the passing of notices from the observed to this background thread.
This implementation of the information notification background thread is quite simple and so uses an anonymous class for the implementation.
Here the thread waits for a new notice on the queue and then sends it to each of the current observers.
As mentioned earlier, consent notifications are performed by the observed's thread. In this way, as soon as any observer opposes the change the observed must reject the change.
Pass along the notice to the background thread.
Here is a small example of using the observation interfaces and classes.
The Sender is an observed. All that it does it to send a stream of notices consisting of sender-id & sequence-number pairs.
The Receiver is an observer. All that it does is to print the notice's facts. In this example all notices are information notifications and so the notice() return value does not matter. However, as a matter of course, notice() should always return true unless it is well sure of the consequences of opposing the change.
Create a few senders.
Create a few receivers.
Have each receiver observe each sender
Startup the senders
Add some sleep of random duration to the current thread.
To build and run this from the command line, first compile using
And then run using
You can show to yourself that the events are ordered by sorting the output on the receiver id and you will see that the events are in numeric order.
The Observer pattern is used to create a relationship between two objects. The relationship is usually unidirectional with the observer waiting for notices from the observed. The relationships is a loose one as the observed only needs to know of the interest of the observer and the observer only needs to know of the set of and ordering of notice the observed will send. A downside of this looseness is that all notices pass through a single observer method for further dispatching.
10 package com.andrewgilmartin.common.observation; 11 12 import java.util.Set; 13 import java.util.concurrent.BlockingQueue; 14 import java.util.concurrent.CopyOnWriteArraySet; 15 import java.util.concurrent.LinkedBlockingQueue; 16
The Observation class is only used to group all the related interfaces and classes into one file. In a typical development environment each interface and class would be in its own file.
22 public class Observation {
23
The Observable is the object that is being watched. As changes are prepared and then made the observable will send consent and information notices to the observers. The notices are normally specialized classes that hold some context about the change. For example, if the notice concerns the addition of new inventory to the warehouse then the notice's class could have a method for enumerating the new inventory.
32 public interface Observable {
33
If it is necessary for the observable to have approval before making a change then a consent notification is sent to the observers. Each observer will be notified and if any observer opposes the change then it must return false. The current thread will be used to notify the observers and so all the observed must wait for all observers to consent.
42 boolean consentNotification(Object notice); 43
An information notification is normally sent after a change. Since the change has already occurred the notices are typically sent asynchronously by a background thread. The order of the notices is preserved, however.
50 void informationNotification(Object notice); 51 } 52
The observer is the object that is notified by the observable. There is no typed relationship beyond the Observable and Observer classes. As mentioned earlier, the notices are usually of specialized classes where each notice instance holds data relevant to the change.
59 public interface Observer {
60
61 boolean notice(Observable observable, Object notice);
62 }
63
A registry is the means of establishing the relationship between the observable and the observer. This interface is distinct from Observable as it is sometimes useful to indirectly register an observer via, for example, a registrar.
70 public interface Registry {
71
The order of the observers is undefined.
75 Set<Observer> getObservers(); 76
Adds the observer to the set of observers. Returns true if the observer was added.
81 boolean addObserver(Observer observer); 82
Removes the observer from the set of observers. Returns true if the observer was among the observers and was removed.
87 boolean deleteObserver(Observer observer); 88 } 89
There is often very little difference between implementations of Observable and Registry and so this base implementation can be widely employed by any class that wants to be observed.
When extending this class make sure to document the set of notices, their consent or information role, and what is their ordering.
98 public static class ObservableBase implements Observable, Registry {
99
The management of the set of observers needs to be thread-safe. The set is expected to be mostly stable over the life of the observed and so copy-on-write semantics is appropriate here.
105 private final Set<Observer> observers = new CopyOnWriteArraySet<Observer>();
Information notification notices will be sent by a background thread. A blocking queue will be used to coordinate the passing of notices from the observed to this background thread.
111 private final BlockingQueue<Object> informationNotices = new LinkedBlockingQueue<Object>();
112
113 public ObservableBase() {
This implementation of the information notification background thread is quite simple and so uses an anonymous class for the implementation.
119 Thread informationEventsDispatcher = new Thread(new Runnable() {
120 @Override
121 public void run() {
122 try {
Here the thread waits for a new notice on the queue and then sends it to each of the current observers.
127 for (;;) {
128 Object notice = informationNotices.take();
129 for (Observer observer : observers) {
130 observer.notice(ObservableBase.this, notice);
131 }
132 }
133 }
134 catch (InterruptedException e) {
135 // empty
136 }
137 }
138 });
139 informationEventsDispatcher.setDaemon(true);
140 informationEventsDispatcher.start();
141 }
142
143 @Override
144 public boolean consentNotification(Object notice) {
As mentioned earlier, consent notifications are performed by the observed's thread. In this way, as soon as any observer opposes the change the observed must reject the change.
150 for (Observer observer : observers) {
151 if (!observer.notice(this, notice)) {
152 return false;
153 }
154 }
155 return true;
156 }
157
158 @Override
159 public void informationNotification(Object notice) {
Pass along the notice to the background thread.
163 informationNotices.add(notice);
164 }
165
166 @Override
167 public Set<Observer> getObservers() {
168 return observers;
169 }
170
171 @Override
172 public boolean addObserver(Observer observer) {
173 return observers.add(observer);
174 }
175
176 @Override
177 public boolean deleteObserver(Observer observer) {
178 return observers.remove(observer);
179 }
180 }
181
Here is a small example of using the observation interfaces and classes.
185 public static void main(String... args) throws Exception {
186
187 class Notice {
188
189 private int senderId;
190 private int sequenceNumber;
191
192 public Notice(int senderId, int sequenceNumber) {
193 this.senderId = senderId;
194 this.sequenceNumber = sequenceNumber;
195 }
196
197 public int getSenderId() {
198 return senderId;
199 }
200
201 public int getSequenceNumber() {
202 return sequenceNumber;
203 }
204 }
205
The Sender is an observed. All that it does it to send a stream of notices consisting of sender-id & sequence-number pairs.
210 class Sender extends ObservableBase implements Runnable {
211
212 private int senderId;
213
214 public Sender(int id) {
215 this.senderId = id;
216 }
217
218 @Override
219 public void run() {
220 for (int sequenceNumber = 0;; sequenceNumber++) {
221 informationNotification(new Notice(senderId, sequenceNumber));
222 sleep(); // add some randomness to the processing.
223 }
224 }
225 }
226
The Receiver is an observer. All that it does is to print the notice's facts. In this example all notices are information notifications and so the notice() return value does not matter. However, as a matter of course, notice() should always return true unless it is well sure of the consequences of opposing the change.
234 class Receiver implements Observer {
235
236 private int receiverId;
237
238 public Receiver(int id) {
239 this.receiverId = id;
240 }
241
242 @Override
243 public boolean notice(Observable observable, Object notice) {
244 if (notice instanceof Notice) {
245 Notice n = (Notice) notice;
246 System.out.printf("notice %d %d %d\n", receiverId, n.getSenderId(), n.getSequenceNumber());
247 sleep(); // add some randomness to the processing.
248 }
249 return true;
250 }
251 }
252
Create a few senders.
256 Sender[] senders = new Sender[5];
257 for (int i = 0; i < senders.length; i++) {
258 senders[i] = new Sender(i);
259 }
260
Create a few receivers.
264 Receiver[] receivers = new Receiver[3];
265 for (int i = 0; i < receivers.length; i++) {
266 receivers[i] = new Receiver(i);
267 }
268
Have each receiver observe each sender
272 for (Receiver r : receivers) {
273 for (Sender s : senders) {
274 s.addObserver(r);
275 }
276 }
277
Startup the senders
281 for (Sender s : senders) {
282 Thread t = new Thread(s);
283 t.setDaemon(false);
284 t.start();
285 }
286 }
287
Add some sleep of random duration to the current thread.
291 static void sleep() {
292 try {
293 Thread.sleep(Math.round(Math.random() * 25));
294 }
295 catch (InterruptedException e) {
296 // empty
297 }
298 }
299 }
To build and run this from the command line, first compile using
303 javac -d /tmp ./src/com/andrewgilmartin/common/observation/Observation
And then run using
308 java -classpath /tmp com.andrewgilmartin.common.observation.Observation
You can show to yourself that the events are ordered by sorting the output on the receiver id and you will see that the events are in numeric order.
314 java -classpath /tmp com.andrewgilmartin.common.observation.Observation | head -20 | sort -k 2 -n -s
317 318 // END
MySql load balancing with HAProxy
We use pair of HAProxy servers at work to route and balance all of our traffic. It is a highly reliable tool with little time or performance overhead. Yesterday I need to balance a load of MySql connections across several slave servers and so used HAProxy to do that. Since I did not find the exact recipe I need on the web here is my test configuration contribution to the MySql global distributed cookbook:
Each MySql server used must have the haproxy user created using
The wildcard can be replaced with the IP address of the HAProxy server.
I want to thank the folks at Homebrew for the haproxy formula.
defaults
mode http
stats uri /haproxy-stats
stats enable
log global
timeout connect 5000ms
timeout client 50000ms
timeout server 50000ms
listen admin
bind *:8000
mode http
listen mysql
bind *:3306
balance leastconn
mode tcp
option tcpka
option srvtcpka
option mysql-check user haproxy
server mysql1 192.168.1.101:3306 weight 1 maxconn 200 check
server mysql2 192.168.1.102:3306 weight 1 maxconn 200 check
server mysql3 192.168.1.103:3306 weight 1 maxconn 200 check
# END
Each MySql server used must have the haproxy user created using
create user 'haproxy'@'%'; flush privileges;
The wildcard can be replaced with the IP address of the HAProxy server.
I want to thank the folks at Homebrew for the haproxy formula.
Low tech needed
And how is this better than writing the inception and expiration dates on the container with a grease pencil?
Where is the call from?
I wish my phone told me where the person was calling from and not where there phone number was registered. I would have been much more prepared to take a call from Matunuck, RI than from Long Beach, CA.
When the solution hides the problem.
A comment on How to Create Your Own 'Dynamic' Bean Definitions in Spring:
The solution hides the problem. I enjoyed reading about the details of the insides of Spring, but the solution was too complicated for the problem. A real value of Spring is that generally it does not get in the way of straightforward solutions. The problem here, picking a datasource based on key could have been handled with a simple DataSource delegate that can pick the actual datasource from an injected mapping of key to datasource. The management of the mapping would be done elsewhere -- JMX, webapp, etc.
For me, the red flag would have been when I thought the solution required a weekend of prototyping to understand the internals of Spring.
This is off topic, but related to picking solutions. You also need to think about the person maintaining your solution. A complex solution will require that the maintainer be at least as talented as you and that can be an unnecessary burden on the organization.
The solution hides the problem. I enjoyed reading about the details of the insides of Spring, but the solution was too complicated for the problem. A real value of Spring is that generally it does not get in the way of straightforward solutions. The problem here, picking a datasource based on key could have been handled with a simple DataSource delegate that can pick the actual datasource from an injected mapping of key to datasource. The management of the mapping would be done elsewhere -- JMX, webapp, etc.
For me, the red flag would have been when I thought the solution required a weekend of prototyping to understand the internals of Spring.
This is off topic, but related to picking solutions. You also need to think about the person maintaining your solution. A complex solution will require that the maintainer be at least as talented as you and that can be an unnecessary burden on the organization.
Cloudbeard
With all the Viking history and fiction I have been reading recently, I would that you now address me as Cloudbeard.
Problem solving sub-101
Is a whole book needed to tell you to solve problems by enumerating the subproblems, stop enumerating when you find one with few dependencies, visualize the dependencies, fix the subproblem, revert the fix when necessary, rinse and repeat. Oh, and give the method a catchy name like The Mikado Method. I don't think so.
Update: This comment was a bit too snarky. I sometimes forget that junior developers do need to be reminded of the basics. And being able to name this is important as the Gang of Four confirmed for us with Design Patterns: Elements of Reusable Object-Oriented Software.
I no longer have patience for certain things
"I no longer have patience for certain things, not because I've become arrogant, but simply because I reached a point in my life where I do not want to waste more time with what displeases me or hurts me. I have no patience for cynicism, excessive criticism and demands of any nature. I lost the will to please those who do not like me, to love those who do not love me and to smile at those who do not want to smile at me. I no longer spend a single minute on those who lie or want to manipulate. I decided not to coexist anymore with pretense, hypocrisy, dishonesty and cheap praise. I do not tolerate selective erudition nor academic arrogance. I do not adjust either to popular gossiping. I hate conflict and comparisons. I believe in a world of opposites and that's why I avoid people with rigid and inflexible personalities. In friendship I dislike the lack of loyalty and betrayal. I do not get along with those who do not know how to give a compliment or a word of encouragement. Exaggerations bore me and I have difficulty accepting those who do not like animals. And on top of everything I have no patience for anyone who does not deserve my patience." -- Meryl Streep
Re: Using exceptions when designing an API
A comment on Using exceptions when designing an API:
When designing an API I use the "get vs find rule." The API's user needs to know how to handle the absence of a result. A get is expected to always return a result while a find is not. And so when coding "getX()" it returns the result or throws an exception -- such as IllegalStateException -- if there is not one. Where as, when coding "findX()" it returns a result if available or a null, or an empty collection, if there not one.
When designing an API I use the "get vs find rule." The API's user needs to know how to handle the absence of a result. A get is expected to always return a result while a find is not. And so when coding "getX()" it returns the result or throws an exception -- such as IllegalStateException -- if there is not one. Where as, when coding "findX()" it returns a result if available or a null, or an empty collection, if there not one.
Quick guide to making PDFs with text outlines from HTML
Create the HTML document.
Use the OS X command line tool wkhtmltopdf to convert the document to pdf
The fonts in this are embedded (or likely to be). To replace the fonts with text outlines use
Done.
<html> <body style="margin: 0; padding: 0"> <div style="width: 2in; height: 2in; border: 1pt solid blue;”> <span style="font-size: 0.5in">Hel</span>lo </div> </body> </html>
Use the OS X command line tool wkhtmltopdf to convert the document to pdf
wkhtmltopdf -B 0 -T 0 -L 0 -R 0 --page-width 2in --page-height 2in box.html box.pdf
The fonts in this are embedded (or likely to be). To replace the fonts with text outlines use
gs -sDEVICE=ps2write -dNOCACHE -sOutputFile=- -q -dbatch -dNOPAUSE -dQUIET box.pdf -c quit | ps2pdf - box-nofont.pdf
Done.
Response to Tom Hoffman's "Peter Greene on Tenure"
Response to "The threat of firing is the great 'Do this or else...'" in Tom Hoffman's Peter Greene on Tenure:
On the whole I find that teachers take on too much accountability and the administration too little. To some degree this is self imposed. I don't know of any other profession that has such a shallow managerial hierarchy. The whole point of a manager is to make this kind of crap go away -- if not in actuality then at least from visibility. Tenure is not the solution and, understandably, sets up teachers for further criticism as being detached from appropriate accountability and economics of their employment. Teaching needs to add management and remove tenure.
On the whole I find that teachers take on too much accountability and the administration too little. To some degree this is self imposed. I don't know of any other profession that has such a shallow managerial hierarchy. The whole point of a manager is to make this kind of crap go away -- if not in actuality then at least from visibility. Tenure is not the solution and, understandably, sets up teachers for further criticism as being detached from appropriate accountability and economics of their employment. Teaching needs to add management and remove tenure.
Inner curmudgeon awoken
My inner curmudgeon was awoken this morning when I read of yet another OS X application for note taking with cloud storage and a corresponding web application. Doesn't anyone know how to use a text editor in conjunction with a remote file service like Google Drive, et al? And, for the vast majority of users, there is no purchase price or recurring fees.
Subscribe to:
Posts (Atom)