text:
Application logging using global inception identifier

March 7, 2015

For multithreaded programs that write to log files a best practice is to include a tracking ID. What should this ID be and how to use it? The following is presented as a ‘design pattern’.

For machine readability and tool use, a non-business related global inception ID (GIID) should be used for every log output. This ID is a combination of an ‘origin id’ and ‘unique id’. When each new business level or operational id is obtained or generated, it is logged to provide an ‘association’ with this GIID. This is similar to various existing practices so it is presented as a Software Design Pattern.

Author: Josef Betancourt, Jan 11, 2015. Originally posted here.

CR Categories: H.3.4 [Systems and Software]; D1.3 [Concurrent Programming]; D.2.9 [Management]; K.6 [MANAGEMENT OF COMPUTING AND INFORMATION SYSTEMS]; K.6.3 [Software Management]

  1. Context
  2. Forces
  3. Solution
  4. Consequence
  5. Implementation
  6. Appendix
  7. Further reading

App Logs

An application log file records runtime programmatic events: details, exceptions, debug, and performance related measures. This is different than specialized server log files, such as a webserver’s access logs, error.log, etc. The latter are more standardized, for example with W3C Extended Log File Format, and well supported.

App logs usually capture details at specific logging levels and named contexts. In the Java ecosystem there are plenty of libraries to support this and now the JDK supports this as part of the java.util.logging package.

Despite the advances made in logging APIs and support within operating systems and frameworks, app logs are at a primitive level of software maturity. What A. Chuvakin and G. Peterson describe as the “… horrific world of application logging” is composed of ad hoc, minimally documented, unstructured, untested, and under-specified delivered components.

Attempts to create widely used industry standards have failed and every business, software project, dev team, or industry reinvents and attempt to tackle the same problems.

In the context of server app logs, multiple sessions will output log information that can be intermixed. These sessions can be part of an ongoing process, such as a user interaction with a web site.

External integration points (web services, database, etc) may also be invoked. Unless each session is identified in the log and integration logs, subsequent support, debug, and auditing are very difficult.

The problem is not just tracking where and when ‘integration’ occurred or its non-functional integration criteria (i.e., timing), but the tracking of subsequent logging, if any, at that location.

App logs are used extensively during development. Their importance is illustrated by an old mime “debuggers are for wimps”. As such, logs with impeccable tracking used for design and test are a good Return On Investment (ROI).

The same is true for deployed systems. In many cases the only information available on historical behavior is in a log file.

This seems like a programming 101 lesson, but it is widely disregarded in practice. That log file output is a minor concern and sometimes not even part of a “code review” is puzzling.

1. A service must invoke a distributed call to another system. The service has retry logic, and logs each failure. If each log output does not identify the session or operation, the retries could get mixed with other threads. Identifying an end user’s request is a hit or miss bracketing of time stamps if the development team did not enough identifiable data in each log output.

2. A computer savvy end user or family may attempt to register into your system with multiple browsers simultaneously. This could cause problems if multiple logins are supported and an error occurs. How do you track this and debug it?

3. The app server makes a remote call to a service integration point and that service fails. How is the owner of that service informed as to the specific invocation? There are probably deployed systems where one would have to compare time stamps on log output to even coordinate where the two systems communicated and even then it is vague. Some systems may not even do any logging and the unless there is a fault of some kind.

4. You have to identify time periods based on hazy user complaints, search through multiple log files with regular expressions, then walk each output to recreate a specific error scenario. Isn’t this manual drudgery what computers were supposed to eliminate?

Global Inception ID

Logging with Unique identifiers is encouraged as a best practice:

“Unique identifiers such as transaction IDs and user IDs are tremendously helpful when debugging, and even more helpful when you are gathering analytics. Unique IDs can point you to the exact transaction. Without them, you might only have a time range to use. When possible, carry these IDs through multiple touch points and avoid changing the format of these IDs between modules. That way, you can track transactions through the system and follow them across machines, networks, and services.” — http://dev.splunk.com/view/logging-best-practices/SP-CAAADP6

This unique identifier is generalized so that on first entry into a system or the start of a process, A Global Inception ID (GIID), is assigned to distinguish that ongoing process from others. A more descriptive term would be a Global Tracking ID, but that conjures up privacy and security concerns and is already being used in commerce for a different purpose. But ‘inception ID’ brings up visions of barcodes on people’s foreheads. Ok, how about “bludzwknxxkjysjkajskjjj”?

The term “Global” is to indicate that this ID is unique in a specific enterprise system. The uniqueness comes from its creation on a first contact basis on a specific subsystem. In essence this is a log tracking ID.

For example, a web server or an app server would be the first point of contact or request from an external User. The GIID, consisting of a combination of origin id and a unique id, would be created at this point. GIID ::= originID uniqueID

In article “Write Logs for Machines, use JSON” Paul Querna uses the term “txnId” for this type of ID:

“… this is essentially a unique identifier that follows a request across all our of services. When a User hits our API we generate a new txnId and attach it to our request object. Any requests to a backend service also include the txnId. This means you can clearly see how a web request is tied to multiple backend service requests, or what frontend request caused a specific Cassandra query.”

Another term for this GIID, or ‘txnId’ is Correlation ID. This terminology is used in SharePoint.

The correlation ID is a GUID (globally unique identifier) that is automatically generated for every request that the SharePoint web server receives.

Basically, it is used to identify your particular request, and it persists throughout further communications, if any, between the other servers in the farm. Technically, this correlation ID is visible at every level in the farm, even at a SQL profiler level and possibly on a separate farm from which your SharePoint site consumes federated services. So for example, if your request needs to fetch some information from an application server (say, if you are using the web client to edit an Excel spreadsheet), then all the other operations that occur will be linked to your original request via this unique correlation ID, so you can trace it to see where the failure or error occurred, and get something more specific than “unknown error”. — https://support.office.com/en-nz/article/SharePoint-2010-Correlation-ID-in-error-messages-what-it-is-and-how-to-use-it-5bf2dba7-43d2-484c-8ef4-e059f76e3efa

Various ‘Structured Logging’ efforts or syslog implementations already contain a ‘sending’ field specification. The GIID incorporates the sender id as the Origin ID, and this combination is more amendable to human and textual tools parsing.

A good candidate for a GIID must be large enough to satisfy uniqueness requirements. This could be, for example, a 36 character field. Where the log files are manually inspected with a text editor, this increases the log line which already contains many common fields like a time stamp.

Unintentionally, “bad” logging practices makes it harder to track and correlate personally identifiable information (PIN). With the use the trans-system GIID, correlation between various business related identifiers is made easier.

The correlation ID is not necessarily a secret, but like other tracking objects like cookies, can be used for information discovery or questionable information storage. But, if an attack can already access your log files, there are other more serious issues?

What determines the first contact subsystem? A true distributed system could be configured or dynamically configured so that any system could be the first contact system. If so, then each subsystem is creating GIID and passing that GIID to other systems that are themselves creating GIIDs.

One approach to handle this is that a system will only create a GIID if none is present in the incoming request.

For user interfaces, exposing the GIID or parts of it in exception situations can be beneficial:

“We also send the txnId to our user’s in our 500 error messages and the X-Response-Idheader, so if a user reports an issue, we can quickly see all of the related log entries.” — https://journal.paul.querna.org/articles/2011/12/26/log-for-machines-in-json/

Compare this to the Hunt The Wampus adventure in enterprises that only have an approximate time of an issue and must track this over multiple systems.

If a giid is part of a support system and as above the ID would be shared with Users in some way, would the value need some form of validity testing? Should it be tested that it is wellformed and include a checksum?

Example crc calculation for a UUID, based on textual version of id:

groovy -e "java.util.zip.Adler32 crc = new java.util.zip.Adler32(); crc.update(UUID.randomUUID().toString().getBytes());println Long.toHexString(crc.getValue())"

Origin ID

An OID uniquely identifies a system in an enterprise. This could be a web server or messaging system. Using a code for the actual system is recommended. Thus, instead of Acctsys, it would be a code, PE65K for example. Using a code is more ‘durable’ than a human readable name.

An extension is to also encode other information in the origin ID, such as application or subsystem identifiers.

Unique ID

This ID must not be a business related entity such as user id or account number. The simple reason is that these may occur in the logging record multiple times for different sessions or transactions. For example, user Jean Valjean with account number 24601 may log in multiple times into a web site. Tracking a specific session if a problem occurs is easier if we use a unique ID.

A business level ID may not even be relevant in another system that interacts with the origin point. In one system the ID could be one type of ID, and in the other the same party or user could be identified with a different ID.

Note that as soon as determined, accessed, or generated, a business level ID should be associated with the GIID. This could be a simple log output of that business ID which, since every log output has a GIID, will associate the business ID or value with the GIID.

Similarly when the same process communicates with another system, that system’s unique identifiers and related business IDs will also be associated with the GIID. For example, a web service will take the GIID and relate it to its own ID(s). Now a support engineer can follow the complete path of the system response to a user session.

ID creation

The easiest approach is to use the entry system’s session id created by the server. A potential problem is that this session id is not guaranteed to be unique and ends when the session expires. A UUID solves most problems.

Sample UUID generation in Groovy language:

groovy -e "println UUID.randomUUID().toString().replace('-','')"

If the system ID is 3491 then the above UUID is used to create the GIID and use in logging:

20110227T23:34:37,901; EV={_ID:”34911f788da1ac4a43bb82adb8e61cfcb205″, USERID:”felixthecat”, ….}

Alternative to UUID use?

A UUID is a 32 character string. Could something smaller be used? Perhaps, but eventually the complexity of threaded systems would make the uniqueness constraint of any ID approach a comparable length.

Other approaches are possible. Most of these will incorporate a timestamp in some way. Note that a UUID contains a timestamp.

An example of a ‘unique’ id is used by MongoDB’s ObjectID specification. That spec calls for a 12-byte BSON type of:
• a 4-byte value representing the seconds since the Unix epoch,
• a 3-byte machine identifier,
• a 2-byte process id, and
• a 3-byte counter, starting with a random value.
An example of an ObjectID string representation is ObjectId(“507f1f77bcf86cd799439011″)

Log Framework support for GIID

The use of a GIID is a ‘cross-cutting’ concern. Requiring programmatic use of this ID would be burdensome and error-prone, even if stored in a thread-safe context.

Some logging frameworks support the concept of “nested diagnostic contexts”. This is a way of storing an ID so that interleaved logging is properly identified. See http://wiki.apache.org/logging-log4j/NDCvsMDC for more information.

Example usage

In a conventional Java server application a JSP or template system would obtain a GIID and insert it into generated pages and associated client side scripts. That GIID would also be stored in the server side session. Since the GIID is stored at the session it is accessible to the various services and components on a server.

This ID is embedded in request to other distributed servers and provides event correlation. Thus the logging systems will have access to the GIID and Client or server side errors can then display or use the GIID for tracking and reporting to assist support engineers.

Since the client also has the GIID, it can display or use this ID for customer service processing.

Of course, this would make more sense if it is a part of a wider Application Service Management (ASM) system.

Standards for IDs

Though many standards specify ID handling, modern architectures, especially web based or distributed, emphasize a stateless protocol. A GIID requirement could be one of those legerdemain stateful practices.

Development impacts

If logging is a deployed feature of an application then it too needs testing. But, since log output is an integration point, it does not fall under the “unit” testing umbrella. There is even some doubt if this should even be tested! Here is one example: Unit Testing: Logging and Dependency Injection
If log files can contain security flaws, convey data, impact support, and impair performance, then they should be tested that they conform to standards. Project management spreadsheets needs to add rows for logging concerns.

Log output can be developer tested using the appropriate XUnit framework, like JUnit.
Mocking frameworks provide a means of avoiding actually sending the output of a logger to an external ‘appender’. “Use JMockit to Unit test logging output”.
In development of a project, the log output changes rapidly as the code changes. Selecting where in the software development life cycle (SDLC) to test logging or even specify what logs should contain is difficult.
One approach is that the deployed system will not do any app logging that was not approved by the stake holders. These must be “unit” tested, and all development support logging is removed or disabled except for use in a development environment.

There is no need to change every subsystem to use this log tracking approach. If the GIID is created somewhere in the “path” of a process or service, it adds value. Other systems can gradually start to use a tracking ID. Thus, the tools and training to use this capability can also be progressively introduced.

About this post

I was going to title this article ‘Logging in Anger’, as a response to my own experiences with application logging. Alas, there are so many issues that I had time to only focus on one as a result of a recent stint supporting an application that exhibits the typical logging anti-patterns. Example: it’s bad to get a null pointer exception, but to not know which argument to a function caused this?

Structured Logging

(this article was going to add more info on incorporating a GIID into a Structured Logging framework. This section is here for refernce)
Structured Logging is a type of app log file that is data based rather than prose based. Thus, it is machine readable and amendable to high-level tools, not just a text editor.

Treating logs as data gives us greater insight into the operational activity of the systems we build. Structured logging, which is using a consistent, predetermined message format containing semantic information, builds on this technique …. We recommend adopting structured logging because the benefits outweigh the minimal effort involved and the practice is becoming the default standard. — http://www.thoughtworks.com/radar/techniques/structured-logging

An example, is a system where the log output uses a predetermined message format. An overview of such systems is found in chapter 5 of “Common Event Expression”, http://cee.mitre.org/docs/Common_Event_Expression_White_Paper_June_2008.pdf

Note this should not be confused with a similar sounding technology called “Log-structured file system”.

Further reading

  1. Log management and intelligence, http://en.wikipedia.org/wiki/Log_management_and_intelligence
  2. Logging a global ID in multiple components, http://stackoverflow.com/questions/1701493/logging-a-global-id-in-multiple-components
  3. Application Service Management (APM) system
  4. Application performance management, http://en.wikipedia.org/wiki/Application_performance_management
  5. The art of application logging, http://www.victor-gartvich.com/2012/05/art-of-application-logging.html
  6. Patterns For Logging Diagnostic Messages, http://c2.com/cgi/wiki?PatternsForLoggingDiagnosticMessages
  8. How to test valid UUID/GUID?
  9. Log Data as a Valuable Tool in the DevOps Lifecycle (and Beyond), http://devops.com/features/log-data-valuable-tool-devops-lifecycle-beyond/
  10. OWASP – Logging Cheat Sheet, https://www.owasp.org/index.php/Logging_Cheat_Sheet
  11. How to Do Application Logging Right, http://arctecgroup.net/pdf/howtoapplogging.pdf
  12. Request for comment Structured Logging, http://www.mediawiki.org/wiki/Requests_for_comment/Structured_logging
  13. 6 – Logging What You Mean: Using the Semantic Logging Application Block, http://msdn.microsoft.com/en-us/library/dn440729(v=pandp.60).aspx
  14. A Review of Event Formats as Enablers of event-driven BPM, http://udoo.uni-muenster.de/downloads/publications/2526.pdf
  15. Basic Android Debugging with Logs, http://www.androiddesignpatterns.com/2012/05/intro-to-android-debug-logging.html
  16. Mapped diagnostic context vs Nested diagnostic context, http://wiki.apache.org/logging-log4j/NDCvsMDC
  17. Building Secure Applications: Consistent Logging, http://www.symantec.com/connect/articles/building-secure-applications-consistent-logging
  18. Log for machines in JSON, https://journal.paul.querna.org/articles/2011/12/26/log-for-machines-in-json/
  19. Logging Discussion, http://c2.com/cgi/wiki?LoggingDiscussion
  20. CEE, http://cee.mitre.org/docs/Common_Event_Expression_White_Paper_June_2008.pdf
  21. CEE is a Failure., https://gist.github.com/jordansissel/1983121
  22. Centralized Logging Architecture, http://jasonwilder.com/blog/2013/07/16/centralized-logging-architecture/
  23. Centralized Logging, http://jasonwilder.com/blog/2012/01/03/centralized-logging/
  24. Logging and the utility of message patterns, http://calliopesounds.blogspot.com/2014/07/the-power-of-javatextmessageformat.html?m=1
  25. Payment Application Data Security Standard, https://www.pcisecuritystandards.org/documents/pa-dss_v2.pdf
    Payment application must facilitate centralized logging.
    Note: Examples of this functionality may include, but are not limited to:
    • Logging via industry standard log file mechanisms such as Common Log File System (CLFS), yslog, delimited text, etc.
    • Providing functionality and documentation to convert the application’s proprietary log format into industry standard log formats suitable for prompt, centralized logging.
    Aligns with PCI DSS Requirement 10.5.3
  26. NIST 800-92 “Guide to Computer Security Log Management”, http://csrc.nist.gov/publications/nistpubs/800-92/SP800-92.pdf
  27. UniqueID Generator: A Pattern for Primary Key Generation, http://java.sys-con.com/node/36169
  28. java.util.logging, http://docs.oracle.com/javase/7/docs/api/java/util/logging/package-summary.html

Dedicating multiprocessors per OS structure

June 5, 2012

A few weeks ago something I’ve been thinking about for a while came back into my thoughts. What if instead of multithreading at the application level, we instead dedicate a chip of a multicore processor to a specific OS resource.

What kind of OS resource? I don’t know. Maybe four processors at ring zero, or at the IO subsystems. We could have application specific cores that are optimized for specific software tasks, just as the new graphic processors are used for APU.

I’m certainly not a system designer and the above is probably pure drivel. Like, how would context switching work and not slow everything down? However, there are possible reasons why perhaps its not.

  • Number of cores will keep growing.
  • GPUs will become more important and powerful.
  • Future applications will be distributed and require advanced resource handling, example, hierarchical robust device systems, like memory handling.
  • Thermal limitations will demand new forms of optimization.
  • AI and robotics applications will reach a tipping point and become ubiquitous, and even more performance will be demanded from computing systems

After thinking about this, I later started seeing articles on internet-on-a-chip, a new way of connecting multicores. Interesting.

Further reading

From Tags To Categories

February 5, 2012

Tags are usually non-hierarchical fine grained descriptors of a resource. They are the opposite of categories which are usually part of a semantic hierarchy. Categories are really old-school, killed by the effectiveness of Search and the expanding mash-up universe.

However, while tags provide rapid access to resources and easier sharing of them, tags do not enrich knowledge. We can see this if we consider knowledge as one of the tiers toward wisdom: data, information, knowledge, wisdom. Tags are data on information, metadata. Categories are information on knowledge.

Since data is used to create information, the data on information, tags, can be harnessed to increase the information on knowledge by the automated creation of categories. We simply create the directed cyclic graphs of tags around resources and detect clusters. The naming of categories come from the resources themselves.

This is how the internet will wake up. It will create an ontology and it will act. Hopefully, humans are part of a necessary category.

Some possible related reading

  1. Ontology on Wikipedia
  2. New Common Tag Format
  3. Semantic Web Use Cases and Case Studies. Case Study: Semantic tags
  4. Ontology is Overrated: Categories, Links, and Tags

State Machine discord as system error detection

October 24, 2011

It takes three subsystem state machines to create an error adaptive system.

This morning in the shower I was thinking about my last post on SCXML. What do you use as states in a system? Easy question, but then I thought, sure its internal states of a process, but how does the external “real” come into the picture, via guards? That could get messy in a very complex real world system. So, what if the external system is also modeled as a state machine?

Now we have two state machines, internal system and external system. What is the advantage? Well, each can have a peak into the other or using historical information, compute how the other works. Then if this prediction is not matched, it is an error. That is, if the internal machine is at state x and it knows that the external machine should be at state y at this point, and it is not, it is a system error. What to do?

This is where a third error machine would come into use. The function of this machine is to bring the other two into resonance, reduce the entropy, heat.

Depending on whether the machines are Mealy or Moore based, one would detect errors at particular points, events, transitions, or states.

I remember reading years ago about fault tolerant hardware systems. The minimum components was three; similar.

Hmmm. I don’t know what everything above really means, if anything. :)

For future thinking …

ATi Radeon 7970 [CAD Animation Benchmark]

Proactive Agents?

June 30, 2011

I read a blog post related to the topic I mentioned, “Synergistic Social Agent Network Cloud“.

The term Proactive Agents is mentioned by Carlos E. Perez, in “Software Development Trends and Predictions for 2011“:

Proactive Agents – For decades people have been forecasting the emergence of digital personal assistants that would actively react to the environment on one’s own behalf. The emergence of always present smart mobile devices and cloud computing shared spaces will be the catalyst for the developing of active agent based computing platforms and frameworks. At present, most computing is merely reactive, that is servicing web requests only on command of a user. Future computing will include a proactive aspect that suggests courses of actions to users. Semantic technologies like Zemanta and OpenCalais provide intelligence to writers by suggesting tags that are relevant to a written document.

Are current social networks, apps, and other mobile devices “proactive” yet?

Java Plain Old Concurrent Object

July 29, 2010

This blog post reiterates the existing critique of the concurrency support in the Java platform and language: that the low level thread and shared memory features should be improved upon with one or more high-level concurrency frameworks. Some of the competing frameworks are listed, and further references are given.

CR Categories: D1.3 [Concurrent Programming]; D.1.5 [Object-oriented Programming]; D.2.2 [Design Tools and Techniques]: Design Tools and Techniques — Software libraries;D3.2 [Language Classifications]: Concurrent, distributed, and parallel languages;D.3.3 [Language Constructs and Features]: Concurrent programming structures;

Keywords and Phrases: concurrency, Java, Actor Model, threads, Component based software engineering, Concurrent object-oriented programming, Distributed systems, Java CSP, CCS, multiprocessor

This is an excerpt from a document I wrote about three years ago.  The doc was in a Java Specification Request (JSR) format and from time to time I updated the link section as I came upon interesting references.   Maybe someone will find it interesting or it will spark a new idea for a project. In a later post I give some examples of concurrent code using the Groovy language.

The Java Platform has built-in support for concurrent programming. At the time of Java’s birth this was very big deal. But, is it now time to build upon this by the creation of a requirements document for high-level concurrency support in the Java language? Could this bring Java closer to a Concurrent Object-Oriented Language (COOL)?

Well, since I’m not a concurrency subject matter expert, just a working stiff developer, I will leave that to others, and just put my two cents here. What prompted me even looking into this subject was my experience on a few projects that required concurrency support.

What is needed is a survey or summary of what exactly are the issues, what is available, what their application areas are, and what are the development options. Some of initial tasks I see, in no particular order, are:

  • State the problem and application scope.
  • Provide use-cases.
  • Create project
    • wiki, forums, etc.
    • conference
  • Limit the scope of the effort.
  • Identify solution categories.
  • Identify solution selection criteria.
  • Testing and management requirements.
  • Measures, such as Performance and scalability.
  • Tools.

One possible conclusion is that there is no need for a ‘higher’ level concurrency support in Java or that this should evolve on its own before attempts at standardization are attempted.

One thing has been left out of the OO frenzy is the concept of a process. There are two manifestations of this: Methodology and Concurrency. In the methodological realm, ‘process’, which was part of data-flow analysis, is practically missing from modern analysis (as typified by OOP/UML derived methods). And even now, modular approaches, are still divorced from concurrency concerns. For example, OSGi fortunately brings back modularity to the Java environment. As stated by Kriens:

“Why is modular important? Well, if there is one consistent lesson in all our technology trends over the past 50 years then it is high cohesion and low coupling. Structured programming advocated this; OO forgot it for some time ….” — Peter Kriens, http://forum.springframework.org/showpost.php?p=138459&postcount=2

Yet, even in OSGi, a module is still at the mercy of unconstrained concurrency effects:

“OSGi … does not provide a thread of execution to each bundle. Events are delivered to bundles through certain interfaces, but no guarantees are made about which thread event delivery occurs on. Generally, event callbacks are required to finish quickly and should not make calls back into the OSGi framework to avoid possible deadlock. It is common, therefore, for bundles to start one or more threads in order to get work done.” — Oliver Goldman, “Multithreading, Java, & OSGi”

Welch calls this “unconstrained OO”:

“In unconstrained OO, threads and objects are orthogonal notions — sometimes dangerously competitive. Threads have no internal structure and can cross object boundaries in spaghetti-like trails that relate objects together in a way that has little correspondence to the original OO design. ” – Peter H. Welch in Javadocs for jcsp.lang.CSProcess of the JCSP library

And, others give similar critiques:

All object methods have to be invoked directly (or indirectly) by an external thread of control – they have to be caller-oriented (a somewhat curious property of so-called object oriented systems). — P.H Welsh (“Process Oriented Design for Java: Concurrency for All”)

“In standard OO, if you hold a reference to friend, and you wish to invoke the borrowMoney() method, then the call friend.borrowMoney() is executed in your own thread of control, not in a separate thread (or in friend’s thread), thus breaking all similarity to the way the real world works.” — (Oprean and Pederson, 2008).

“Although the development of parallel languages began around 1972, it did not stop here. Today we have three major communication paradigms: monitors, remote procedures, and message passing. Any one of them would have been a vast improvement over Java’s insecure variant of shared classes. As it is, Java ignores the last twenty-five years of research in parallel languages.”
— JAVA’S INSECURE PARALLELISM by Per Brinch Hansen (1999)

“However, I think Java needs to change. When it was first released, its number one competitor was C++, and Java walked all over it in terms of support for concurrency. Threads in the standard library! Syntactic support for critical blocks! Implicit locks in every object! Now, Java’s number one competitor is C#, which is increasingly starting to look like a functional language. Also languages like Erlang and Haskell have concurrency primitives that walk all over Java’s (I particularly love Haskell’s composable memory transactions). I hope this is something that is addressed in Java 7, but I fear it won’t be…” — Neil Bartlett

A higher level concurrency support in Java will allow a more approachable use of concurrent development. Though the concurrency implementation in Java is a vast improvment over what was available in a popular language at the time, we are now seeing more interests in other approaches as shown in Scala, Erlang, Kilim, Akka, GPars, Haskell, and others.

A standard would then allow, within reason, the sharing of development expertise and common patterns and idioms among the different languages and frameworks. For example, could an Actor in Scala be behaviorially the same as an Actor in plain old Java?

We are also seeing multiple processor cores being used to continue the improvment in thruput since thermal and process limititions have reduced growth. These will also allow true parallism. A high-end actual product, Sparc T3, the Sun Microelectronics version of the chip multi-threaded (CMT) processor, will be capable of forming a quad core SOC (System on Chip) that offers 512 hardware threads. Even on personal desktop systems, we already have quad cores and soon hexacores will be commonplace in the high end, such as the Intel Nehalem-EX. (Note that concurrency and parallelism are not the same thing).

Update: This was written a while back. In the interim, Oracle bought Sun and in the process canceled the Rock high-end CMT based processor design. Yet, Oracle said they will continue to support the upcoming SPARC CMT versions. Interesting discussion is found here. Intel and AMD have not stood still. AMD, for example, is promising a 16 core “Interlagos” chip soon. On the mobile side, ARM and others are also producing multicore systems.

Plain Old Concurrent Component

Instead of just reusing existing terms, I can call this new concurrency support a Concurrent Component. A component is more similar to an OS process, whereas internally it may incorporate light weight threads.

A possible conceptual view of a Component or Plain Old Concurrent Object (POCO) is shown in figure 1 below . Note that this is intentionally reminiscent of a Programmable Logic Device (PLD) block diagram. Each block is an optional ‘concern’ that crosscuts each object that is part of the component. The nested objects can share state and optionally will execute within a fine-grain concurrency kernel. The external control communication is via interfaces that expose the Component API, whereas the actual messaging embeds the application API that the component instantiation provides. This is somewhat of the flavor of Cox’s Software IC concept (ref?). This is also similar to various old Microsoft COM models. In future, it’s even conceivable that each POCO could have its own core assigned in an dynamically created application specific multicore processor implemented in nanoprocessor FPGA.

And, yes the diagram is just my brain’s core dump on the subject. Would require more work to explore this further, and determine what would really make sense.

Concurrent Component

Why isn’t this need met by existing specifications?

Currently, developers can use the concurrency control constructs that are provided in the Java language itself. Many experts consider these too low level for some applications and for use by the average developer (in terms of development effort, correctness, and failure potentials):

Use Erlang-Style Concurrency. The Java concurrency primitives like locks and synchronized have been proven to be too low level and often to hard to use. There are better ways to write concurrent code. Erlang Style concurrency is one of them – in Java there are many ways to achive this in Java – I’ve written about them here. Newer ones are Akka and Actorom. You can also use Join/Fork or the myriad of data structures in java.util.concurrent. —- Stephan Schmidt in Go Ahead: Next Generation Java Programming Style

In Java 5 and above one uses the new java.util.concurrent utilities. These offer a powerful and relatively accessible API such as the Executor and the Fork/Join frameworks. However, though the latter were a significant improvement, their use still require advanced skills and really only offer the means to create application specific or JVM language based concurrency frameworks.

Even with concurrency updates in Java 6 and Java 7, the Java language doesn’t make parallel programming particularly easy. Java threads, synchronized blocks, wait/ notify, and the java.util.concurrent package all have their place, but Java developers pressed to meet the capacity of multi-core systems are turning to techniques pioneered in other languages.

— “A Java actor library for parallel execution

Some languages or libraries, such as Scala (?) and JCSP even use the underlying concurrency support in Java to create the respective ‘active’ object concurrency extensions. See for instance this presentation by Doug Lea, “Engineering Fine-Grained Parallelism Support for Java 7″.

Note that introducing a higher level of abstraction will not necessarily reduce the need for skilled engineering. In fact, it may increase that need until the patterns, methodologies, measurement, and tool sets catch up and support the new framework. Of course, many other concerns are important, such as performance.

Underlying technology or technologies:

There is a rich history in both industrial and academic research into the theory and practices of concurrency. In the fifty plus years of this, surely there must be more that can be used in Java then Monitors, semaphores and other low level tools.

Some examples are Communicating Sequential Processes (CSP), Calculus of communicating systems (CCS), and all the ‘proven’ concurrent support already found in other languages, among them, Occam, Go, Erlang, Haskell, Esterel, Scala, and many others in the academic research community. There is even one observation that the current Monitor implementation in Java itself could more fully embrace the original theoretical Monitor concept.

Of course, as in anything else, there is hype and fashion in software too. Thus, some approaches are touted as fixing deadlocks and other problems, when they don’t.

Related Projects:

· Disruptor – Concurrent Programming Framework
· LMAX: “The LMAX Architecture“, Fowler, M., http://martinfowler.com/articles/lmax.html
· CQRS: CQRS, Fowler, M., http://martinfowler.com/bliki/CQRS.html
· Akka: http://akkasource.org/
· Multiverse: http://multiverse.codehaus.org/overview.html
· ESTEREL: http://www-sop.inria.fr/meije/esterel/esterel-eng.html
· Staged event-driven architecture (SEDA)
· CSP: http://www.usingcsp.com/cspbook.pdf
· Kilim: http://www.malhar.net/sriram/kilim/index.html
· JCSP: http://www.cs.ukc.ac.uk/projects/ofa/jcsp
· JVSTM: http://web.ist.utl.pt/joao.cachopo/jvstm/
· Clojure: http://clojure.org/concurrent_programming
· “Gpars: http://gpars.codehaus.org/
· Groovy Parallel: http://www.dcs.napier.ac.uk/~cs10/GroovyParallel/
· Scala: http://www.scala-lang.org/
· Triveni: http://webpages.cs.luc.edu/~laufer/triveni/
· ActorFoundry project, http://osl.cs.uiuc.edu/af/
· “Jetlang, Message based concurrency for Java” http://code.google.com/p/jetlang/
· Jsasb, adds event-driven programming paradigm to Java, https://jsasb.dev.java.net/
· Node.js: http://nodejs.org/
. Er.js: Er.js: Erlang-in-JavaScript
· MPJ: Java for High Performance Computing, http://mpj-express.org/
· FunctionalJava, accessed on 3/2/2009 at http://functionaljava.org/
· JAVACT : a Java middleware for mobile adaptive agents, accessed on 3/2/2009 on 3/2/2009 at http://www.irit.fr/PERSONNEL/SMAC/arcangeli/JavAct.html
· Threading in COM, accessed on 3/2/2009 at http://en.wikipedia.org/wiki/Component_Object_Model#Threading_in_COM
· http://www.transterpreter.org/
· http://supertech.csail.mit.edu/cilk/
· TBB: http://www.threadingbuildingblocks.org/
· JConch: http://code.google.com/p/jconch/
· JAC: http://www.inf.fu-berlin.de/inst/ag-ss/jac/
· X10: http://docs.codehaus.org/display/XTENLANG
· COSA: http://www.rebelscience.org/Cosas/COSA.htm
· BAM: http://caucho.com/resin/doc/bam.xtp
· Concurrent Programming Research Group, http://mypages.iit.edu/~concur/
· JCarder, http://www.jcarder.org/
· Go, http://golang.org/doc/go_lang_faq.html#concurrency
· Panini: http://www.cs.iastate.edu/~design/projects/panini/

Further Reading

Below are a few easily obtainable links found on-line. (To do: use standard style guide like IEEE Standard and Chicago).

· Coarse-grained locks and Transactional Synchronization explained

· Concepts compared

· “Joe Duffy on the Future of Concurrency and Parallelism

· Dr. Dobb’s Report: Real-Time Ready Java

· Actors Make Better Observers

· Talking about Akka, Scala and life with Jonas Bonér

· Miller, Alex; Comparing concurrent frameworks

· Lea, Doug; “Engineering Fine-Grained Parallelism Support for Java 7″, http://www.dzone.com/links/r/engineering_finegrained_parallelism_in_java.html

· Milewsk, Bartosz; “Beyond Locks and Messages: The Future of Concurrent Programming”, http://bartoszmilewski.wordpress.com/2010/08/02/beyond-locks-and-messages-the-future-of-concurrent-programming/

· Wiger, Ulf; “Death by Accidental Complexity”, http://lambda-the-ultimate.org/node/1630

· “Erlang concurrency: why asynchronious messages?”, http://lambda-the-ultimate.org/node/1630″>http://lambda-the-ultimate.org/node/1630

· Merritt, Eric;”A Brief Overview of Concurrency.”, http://erlware.blogspot.com/2010/07/brief-overview-of-concurrency.html

· Kuppusamy, Rmsundar; “Is concurrency such a complex thing in real world applications?”, http://www.dzone.com/links/r/is_concurrency_such_a_complex_thing_in_real_world.html; Comments on the article are very informative.

· Kabutz, Heinz; “Deadlocks through Cyclic Dependencies”, http://www.javaspecialists.eu/archive/Issue184.html

· Jackson, Joab, “Microsoft Windows architect says ditch the kernel”, http://news.techworld.com/operating-systems/3217766/microsoft-windows-architect-says-ditch-the-kernel/?olo=rss

· Breshears, Clay, “Across the wide Concurrency”, http://software.intel.com/en-us/blogs/2010/05/17/across-the-wide-concurrency/

· Dibyendu Roy, “Rethinking Multi-Threaded Design Principles”, [Weblog entry.] Java.net. 3 Mar 2010. (http://today.java.net/article/2010/03/03/rethinking-multi-threaded-design-priniciples). 5 Mar 2010.

· Mordani, Rajiv; “Asynchronous Support in Servlet 3.0″, http://blogs.sun.com/enterprisetechtips/entry/asynchronous_support_in_servlet_3

· Michele Simionato, “Threads, processes and concurrency in Python: some thoughts”, [weblog entry.] The Explorer. 26 Jul 2010. (http://www.artima.com/weblogs/viewpost.jsp?thread=299551). 26 Jul 2010.

· Orlic, Bojan; “SystemCSP : a graphical language for designing concurrent component-based embedded control systems”. (2007) thesis. http://doc.utwente.nl/58009/

· Jonas Bonér, “Introducing Akka – Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors”. 4 Jan 2010. (http://jonasboner.com/2010/01/04/introducing-akka.html). 14 Mar 2010.

· Stephan Schmidt, “Actor Myths”, [Weblog entry.] Code Monkeying. Jul 21, 2010. (http://codemonkeyism.com/actor-myths/)

· James Iry. “Erlang Style Actors Are All About Shared State”, [Weblog entry.] One Div Zero. 6 Apr, 2009. (http://james-iry.blogspot.com/2009/04/erlang-style-actors-are-all-about.html) . 23 Jul 2010.

· Paul Chiusano, “Actors are not a good concurrency model”, [Weblog entry.] Prettt-tty, pretty, pretty good!. 15 Jan 2010. (http://concurrency.tumblr.com/post/420147030/actors-are-not-a-good-concurrency-model). 2. Mar 2010.

· Welch, P.H.; “Process Oriented Design for Java: Concurrency for All”, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=

· Dimitris Andreou, “Thoughts on Actors”, [Weblog entry.] Code-o-matic. 8 Jan 2010. (http://code-o-matic.blogspot.com/2010/01/thoughts-on-actors.html). 23 July 2010.

· McDonald, Carol; “Some Java Concurrency Tips”, http://weblogs.java.net/blog/caroljmcdonald/archive/2009/09/17/some-java-concurrency-tips

· Oprean, George and Pedersen, Jan B., “Asynchronous Active Objects in Java”, Communicating Process Architectures, 2008., http://wotug.org/paperdb/show_proc.php?f=4&num=26

· sutter, Herb; “Prefer Using Active Objects Instead of Naked Threads”, http://www.drdobbs.com/high-performance-computing/225700095;jsessionid=OCHVVY5DWODL3QE1GHRSKHWATMY32JVN

· Alex Tkachman, “Groovy concurrency in action: asynchronious resource pools with Groovy++”, http://groovy.dzone.com/articles/groovy-concurrency-action-0

· Alex Tkachman, “Fast immutable persistent functional queues for concurrency with Groovy”, JavaLobby, http://java.dzone.com/articles/fast-immutable-persistent

· Schumacher, Dale, “Composing Actors”, “blog It’s Actors All The Way Down”, http://www.dalnefre.com/wp/2010/05/composing-actors/

· “Objects as Actors?”, Debasish Ghosh, http://java.dzone.com/news/objects-actors

· “Gartner Says as the Number of Processors Swells Inside Servers, Organizations May Not Be Able to Use All Processors Thrust on Them”, http://www.gartner.com/it/page.jsp?id=867112

· “Tilera vs. Godzilla”, Louis Savain, http://rebelscience.blogspot.com/2007/08/tilera-vs-godzilla.html

· “Convergence in Language Design: A Case of Lightning Striking Four Times in the Same Place”, Peter Van Roy, http://www.info.ucl.ac.be/~pvr/flopsPVRarticle.pdf

· “The Problem with Threads”, Edward A. Lee, http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.pdf

· “A Component-Oriented Language for Pointer-Free Parallel Programming”, Luc BlÄaser, Computer Systems Institute, ETH ZÄurich, Switzerland. Accessed on 3/10/2009 at http://www.isp.uni-luebeck.de/kps07/files/papers/blaeser.pdf

· Mauricio Arango, “Coordination in parallel event-based systems”, http://blogs.sun.com/arango/entry/coordination_in_parallel_event_based

· Irfan Pyarali, Tim Harrison, and Douglas C. Schmidt Thomas D. Jordan; “Proactor: “An Object Behavioral Pattern for Demultiplexing and Dispatching Handlers for Asynchronous Events”, http://www.cs.wustl.edu/~schmidt/PDF/proactor.pdf

· “A Component-Oriented Model for the Design of Safe Multi-threaded Applications”, Reimer Behrends, R. E. K. Stirewalt and L. K. Dillon Dept. of Computer Science and Engineering Michigan State University, accessed on 3/10/2009 at http://www.cse.msu.edu/~stire/Papers/cbse05.pdf

· “2028: Concurrent processing–from revolution to legacy”, http://www.embedded.com/design/212000158

· “Join Patterns for Visual Basic”, accessed on 3/10/2009 at http://research.microsoft.com/en-us/um/people/crusso/papers/cb.pdf

· “ActorsModel”, at http://c2.com/cgi/wiki?ActorsModel

· “Sharing Is the Root of All Contention”,Herb Sutter, http://www.ddj.com/go-parallel/article/showArticle.jhtml?articleID=214100002

· Bryan Cantrill. “OpenSolaris Sewer Tour”. [weblog entry.] The Observation Deck. 14 Jun 05. (http://blogs.sun.com/bmc/entry/opensolaris_sewer_tour). 26 Jul 10.

· “Concurrent computing”, http://en.wikipedia.org/wiki/Concurrent_computing

Walsh, Matt; “SEDA: An Architecture for Highly Concurrent Server Applications”, Harvard University,

· “Multicore programming: Easy or difficult?”, http://www.edn.com/article/CA6646279.html?nid=2551

· “The universe model: An approach for improving the modularity and reliability of concurrent programs, Reimer Behrends”, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=

· Mitchell Pronschinske, “Concurrent Programming in Groovy”, JavaLobby, http://java.dzone.com/articles/dont-be-afraid-try-gpars

· “Actors in Groovy”, Alex Miller, http://tech.puredanger.com/2009/01/16/actors-in-groovy/

· “Scala Actors vs Plain Old Java”, Duke Banerjee, http://shorugoru.blogspot.com/2009/09/scala-actors-vs-plain-old-java.html

· Event-based actors in Groovy, Václav Pech, accessed on 3/4/09 at http://www.jroller.com/vaclav/entry/event_based_actors_in_groovy

· Pech, Václav; “Flowing with the data”, http://www.jroller.com/vaclav/entry/flowing_with_the_data

· “We haven’t forgotten about other models – honest!”, posted to Maestro blog, accessed on 3/02/2009 at http://blogs.msdn.com/maestroteam/archive/2009/02/27/we-haven-t-forgotten-about-other-models-honest.aspx

· ” Infrastructure for the Synchronization and Coordination of Concurrent Java Component Programs”, Sandeep Mitra, Sudhir Aggarwal, accessed on 2/28/09 at http://csdl.computer.org/comp/proceedings/hicss/2000/0493/08/04938052.pdf

· Parallel Computing Developer Center, http://msdn.microsoft.com/en-us/concurrency/default.aspx

· Search on CiteSeer for STM: http://citeseerx.ist.psu.edu/search;jsessionid=832BC25C661FF28D18EDAE10E725B301?q=software+transactional+memory&submit=Search&sort=rel

· “Synchronization and Time”, Duffy, Joe; http://www.bluebytesoftware.com/books/winconc/ConcurrentProgramming032143482X_ch02.pdf

· “Concurrency’s Shysters”, http://blogs.sun.com/bmc/entry/concurrency_s_shysters

· “More thoughts on transactional memory”, Duffy, Joe; http://www.bluebytesoftware.com/blog/PermaLink,guid,94778838-3e27-4788-a935-006ae9c8ef94.aspx

· “And now some Hardware Transactional Memory comments…”,Cliff Click Jr., http://blogs.azulsystems.com/cliff/2009/02/and-now-some-hardware-transactional-memory-comments.html

· “Communicating Java Threads” (1997),,Gerald Hilderink, Jan Broenink, Wiek Vervoort, Andre Bakkers, http://www.ce.utwente.nl/javapp/cjt/CJT-paper.PDF

· “Actors That Unify Threads and Events”,Philipp Haller and Martin Odersky, http://lamp.epfl.ch/~phaller/doc/haller07coord.pdf

· Discussion at Lambda the Ultimate: http://lambda-the-ultimate.org/node/2048

· “The Next Mainstream Programming Language”, http://www.cs.princeton.edu/~dpw/popl/06/Tim-POPL.ppt

· “Actor Foundry”,”Rajesh Karmani, et al.”,http://osl.cs.uiuc.edu/~rkumar8/ActorFoundry.ppt

· “Implementing the π-Calculus in Java”,Liwu Li, http://www.jot.fm/issues/issue_2005_03/article5.pdf

· “Tackling Concurrency Language or Library?”,http://www.scala-lang.org/sites/default/files/odersky/intel06.pdf

· “Programming in the Age of Concurrency: Software Transactional Memory”,http://channel9.msdn.com/shows/Going+Deep/Programming-in-the-Age-of-Concurrency-Software-Transactional-Memory/

· “Communicating Process Architectures 2008″, Editors: Frederick R. M. Barnes, Jan F. Broenink, Alistair A. McEwan, Adam Sampson, G. S. Stiles, Peter H. Welch; IOS Press, Amsterdam, 978-1-58603-90. http://wotug.org/paperdb/show_proc.php?f=4&num=26 Accessed 26 Jul 10.

· “CSP for Java programmers, Part 1“,Abhijit Belapurkar, http://www-128.ibm.com/developerworks/java/library/j-csp1.html

· “CSP for Java programmers, Part 2“,Abhijit Belapurkar, http://www.ibm.com/developerworks/java/library/j-csp2/

· “CSP for Java programmers, Part 3“,Abhijit Belapurkar, http://www.ibm.com/developerworks/java/library/j-csp3.html

· More Java Actor Frameworks Compared, http://sujitpal.blogspot.com/2009/01/more-java-actor-frameworks-compared.html, Sun Jan 04 2009 09:24:04 GMT-0500 (Eastern Standard Time)

· Concurrency, Actors and Kilim, http://sujitpal.blogspot.com/2008/12/concurrency-actors-and-kilim.html, Sun Jan 04 2009 09:24:54 GMT-0500 (Eastern Standard Time)

· Event-Based Programming without Inversion of Control,
Philipp Haller and Martin Odersky, Proc. JMLC 2006, and. Accessed 2007 at http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf

· Actors that Unify Threads and Events,
Philipp Haller and Martin Odersky, Proc. COORDINATION 2007. Accessed 2007 at http://lamp.epfl.ch/~phaller/doc/haller07coord.pdf

· “Integrating and Extending JCSP”, Peter WELCHa, Neil BROWNa, James MOORES b, Kevin CHALMERS c and Bernhard SPUTH. Communicating Process Architectures 2007. Accessed 2007 at xxxx.

· “Message Passing–Sync or Async?”, Bartosz milewski, http://bartoszmilewski.wordpress.com/2009/02/10/message-passing-sync-or-async/

· A message thread about Erlang related questions, http://www.erlang.org/pipermail/erlang-questions/2008-January/032224.html

· “Are Concurrent Programs That Are Easier to Write Also Easier to Check?”, Kedar S. Namjoshi, accessed 20081228 at http://www.cs.utah.edu/ec2/papers/ec2-pp7.pdf

· Goldman, Oliver. “Multithreading, Java, & OSGi.” http://www.ddj.com/java/191601642.

· Vogel, Lars. “Java Concurrency / Multithreading – Tutorial”, http://www.vogella.de/articles/JavaConcurrency/article.html

· “Thread-safety in OSGi”, Neil Bartlett, accessed at http://neilbartlett.name/blog/2007/03/05/thread-safety-in-osgi/

· Ernst, Dan.”Parallelism Exposure – It’s Not That Hard!“,

· “Kilim: Isolation-typed actors for Java”, Sriram Srinivasan, http://www.malhar.net/sriram/talks/kilim-google.pdf

· “Wot, no chickens?”, http://wotug.org/parallel/groups/wotug/java/discussion/3.html

· “Java for High Performance Computing”, http://mpj-express.org/

· “4.5 Active Objects”, http://gee.cs.oswego.edu/dl/cpj/s4.5.html

· “Rock (processor)”, http://en.wikipedia.org/wiki/Rock_processor

· “Early Experience with a Commercial Hardware Transactional Memory Implementation”,Dave Dice, Yossi Lev, Mark Moir, and Dan Nussbaum, http://blogs.sun.com/dave/resource/asplos09-Rock-Final2.pdf

· “Concurrency JSR-166 Interest Site”, http://gee.cs.oswego.edu/dl/concurrency-interest/index.html

· “Actors Guild”, http://actorsguildframework.org/

· Synchronous Active Objects Home Page, http://ltiwww.epfl.ch/sJava/index.html

· “What after Java? From objects to actors”,Carlos A. Varela and Gul A. Agha, http://www7.scu.edu.au/1890/com1890.htm

· “Programming Java threads in the real world, Part 9”, Allen Holub, JavaWorld.com, 06/01/99, http://www.javaworld.com/javaworld/jw-06-1999/jw-06-toolbox.html

· Actors Foundations for Open System: http://www.erights.org/history/actors.html

· “Power Combination: SCA,, OSGi and Spring”, OSOA Collaboration, http://www.osoa.org/download/attachments/250/Power_Combination_SCA_Spring_OSGi.pdf

· There Is a Silver Bullet, Brad J. Cox, http://www.ddj.com/184407534

· Concurrency and Coordination Runtime, http://en.wikipedia.org/wiki/Concurrency_and_Coordination_Runtime

· Yuri Gurevich, Wolfram Schulte, and Charles Wallace, “Investigating Java Concurrency using Abstract State Machines”. In Y. Gurevich, P. Kutter, M. Odersky, and L. Thiele, eds., Abstract State Machines: Theory and Applications, Springer LNCS 1912, 2000, 151-176.

· Understanding actor concurrency, Part 1: Actors in Erlang A new way to think about structuring concurrent applications By Alex Miller, JavaWorld.com, 02/24/09, http://www.javaworld.com//javaworld/jw-02-2009/jw-02-actor-concurrency1.html

· “Understanding actor concurrency, Part 2: Actors on the JVM”, http://www.javaworld.com/javaworld/jw-03-2009/jw-03-actor-concurrency2.html

· Byrne, Dennis; “Memory Barriers and JVM Concurrency”, InfoQ, http://www.infoq.com/articles/memory_barriers_jvm_concurrency

· Thread Safe Programming Language, Stefan Forster, http://threadsafeprogramming.blogspot.com/2009/03/threadsafeprogramminglanguage.html

· Maestro: A Special-Purpose Language for Parallel Programming, Jonathan Erickson, http://www.ddj.com/go-parallel/article/showArticle.jhtml?articleID=214502187

· Message Passing Interface (MPI), http://en.wikipedia.org/wiki/Message_Passing_Interface

· “Best programming approach/methodology to assure thread safety”, http://stackoverflow.com/questions/256517/best-programming-approach-methodology-to-assure-thread-safety/256684

· “RPC and its Offspring: Convenient, Yet Fundamentally Flawed”, Steve Vinoski”, http://qconlondon.com/london-2009/file?path=/qcon-london-2009/slides/SteveVinoski_RPCAndItsOffspringConvenientYetFundamentallyFlawed.pdf

· “Bigraphs: a model for mobile agents”, Robin Milner, Accessed on 3/3/2009 at http://www.cl.cam.ac.uk/~rm135/Bigraphs-Lectures.pdf

· “Fine-grain concurrency”, Tony Hoare, accessed on 3/3/2009 at http://se.inf.ethz.ch/laser/2007/slides/guildford.Fine-grain%20concurrency.pdf

· P. Brinch Hansen, A keynote address on concurrent programming. Keynote address for the IEEE Computer Software & Applications Conference, Chicago, IL, November 1978. Computer 12, 5 (May 1979), 50{56. Copyright °c 1979, Institute of Electrical and Electronics Engineers, Inc., accessed on 3/3/09 at http://brinch-hansen.net/papers/1978c.pdf

· “Concurrency: The Next Generation”, Damian Dimmich, Christian Jacobsen and Matthew Jadud, Computing Laboratory University of Kent Canterbury, CT2 7NZ, accessed on 3/3/09 at http://www.cs.kent.ac.uk/pubs/2006/2522/content.pdf

· “Concurrency and Erlang” LCA2007 Andre Pang, http://www.scribd.com/doc/415195/Concurrency-and-Erlang-LCA2007-Andrep

· “Concurrency in Erlang & Scala: The Actor Model”, Ruben Vermeersch, http://ruben.savanne.be/articles/concurrency-in-erlang-scala

· Erlang for Concurrent Programming, Jim Larson, http://queue.acm.org/detail.cfm?id=1454463

· How OSGi Changed My Life, Peter Kriens, http://queue.acm.org/detail.cfm?id=1348594

· “New parallel programming language design: a bridge between brain models and multi-core/many-core computers?”, http://arxiv.org/PS_cache/arxiv/pdf/0812/0812.2926v1.pdf

· Component-based software engineering, http://en.wikipedia.org/wiki/Software_componentry

· “Component-based approach for embedded systems”, Ivica Crnkovic Mälardalen University, Department of Computer Science and Engineering, http://research.microsoft.com/en-us/um/people/cszypers/events/wcop2004/18-crnkovic.pdf

· Super Actors for Real Time (2001), G. Fortino, L. Nigro, F. Pupo, D. Spezzano, Proc. of the 6 th IEEE Workshop on Object-oriented Real-time Dependable Systems (WORDS’01 http://si.deis.unical.it/~fortino/research/publications/conferences/pdf/words01.pdf

· “Fundamentals of Concurrent Programming for .NET” (2005), Charteris White Paper, Greg Beech, http://www.charteris.com/publications/white_papers/downloads/White Papers – Fundamentals of Concurrent Programming for dotNET (Greg Beech) March 2005.pdf

· “A type safe state abstraction for coordination in Java-like languages”,Ferruccio Damiani, Elena Giachino, Paola Giannini, and Sophia Drossopoulou,Acta Informatica, Volume 45, Numbers 7-8 / December, 2008, http://www.springerlink.com/content/2168q630k2355563/

· The Art of Concurrency: A thread Monkey’s Guide to Writing Parallel Applications, Clay Breshears, O’Reilly Media, May 2009. 978-0-596-52153-0. http://oreilly.com/catalog/9780596521547

· Concurrency: State Models & Java Programs, Jeff Magee and Jeff Kramer

· Java Concurrency in Practice, Brian Goetz

· Concurrent Programming in Java, Doug Lea,

· Java Thread Programming, Paul Hyde,

· Java Threads, Oaks & Wong,

· Multithreaded Programming with Windows NT, Thuan Q. Pham and Pankaj K. Garg

· From “Industry Education Recommended Reading List”, http://www.intel.com/technology/rr/

o C# Threading Handbook, Tobin Titus, Sandra Gopikrishna, Tejaswi

o Redkar, Srinivasa Sivakumar, Wrox Press 1861008295

o Computer Architecture: A Quantitative Approach 4th Edition John L. Hennessy and David Patterson Morgan Kaufmann 0123704901

o Multi-Core Programming Shameem Akhter, Jason Roberts Intel Press 0976483246

o Multithreading Applications in Win32: The Complete Guide to Threads Jim Beveridge, Robert Wiener Addison-Wesley Professional 0201442345

o Parallel Programming in C with MPI and OpenMP Michael J. Quinn McGraw-Hill Professional 0072822562

o Parallel Programming in OpenMP Rohit Chandra, Ramesh Menon, Leo Dagum, Dave Kohr, Dror Maydan, and Jeff McDonald Morgan Kaufmann 1558606718

o Using OpenMP: Portable Shared Memory Parallel Programming Barbara Chapman, Gabriele Jost, Ruud van der Pas, David J. Kuck MIT Press 0262533022

o Parallel Programming with MPI Peter Pacheco Morgan Kaufmann 1558603395

o Patterns for Parallel Programming Timothy G. Mattson, Beverly A. Sanders, Berna L. Massingill Addison-Wesley Professional 0321228111

o The Art of Concurrency Clay Breshears O’Reilly 9780596521530

o Programming with Hyper-Threading Technology Andrew Binstock, Richard Gerber Intel Press 0971786143

o Programming with POSIX® Threads David R. Butenhof Addison-Wesley Professional 0201633922

o The Software Optimization Cookbook, Second Edition Richard Gerber, Aart J.C. Bik, Kevin Smith, Xinmin Tian Intel Press 0976483211

o Optimizing Applications for Multi-Core Processors Stewart Taylor Intel Press 1934053015

o Intel Threading Building Blocks: Outfitting C++ for Multi-Core Processor Parallelism James Reinders O’Reilly 0596514808

o Threads Primer: A Guide to Multithreaded Programming Bil Lewis, Daniel J. Berg Prentice Hall 0134436989

Modular Continuously Shippable Applications

June 14, 2010

Long ago in 2000 at a job I suggested to the development teams that an approach we could use is to start on day one with a shippable product.  That is, using Stubs, Mocks, and fake data, we could create the complete app that is testable and shippable from day one.  Since the first customers are the investors and potential partners, they would get to see what we really intended to create up front, in working code, not fancy PowerPoint presentations.  The working code would have served as the presentation and the base on which to build the eventual product to ship to external customers.

This was not just a test-driven development (TDD) approach, I said. For example, we could use a Command Line Interface until we have the Rich Internet Application framework ready, we could use flat-files until we knew what the data model should be, etc.  The “product” was in flux based on potential customer feedback.  So, it was really to do the simplest thing that will get the application doing real work as soon as possible.

The advantages I thought could have been:

  • Faster to market
  • Better API (no fluff)
  • System always testable
  • Infrastructure for testing and QA
  • Usable for presentation
  • Modular

What was the response?  Nothing.  Oh well.  It would have been great to see what could have been accomplished.

I was reminded of the above as I stumbled upon “Architecture Review: Mock-Driven Three-Layer Architecture“ on James Shore’s The Art of Agile blog.

Now there has been much more creative work and new agile languages that would have made my idea more doable.  In fact, many of today’s successful frameworks are responses to the excess complexity that I had to deal with then.

“Potentially Shippable product – A Myth or Reality?”: http://agileworld.blogspot.com/2009/11/potentially-shippable-product-myth-or.html

Continuous Integration:  http://en.wikipedia.org/wiki/Continuous_integration

“Learn how to Pivot — or you’re toast”: http://bit.ly/aa80CL

Mock Object: http://en.wikipedia.org/wiki/Mock_object

Mock-Driven Three-Layer Architecture”, http://jamesshore.com/Blog/Architecture-Review-Mock-Driven-Three-Layer-Architecture.html

“Mocks Aren’t Stubs”, http://martinfowler.com/articles/mocksArentStubs.html

“Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))”, http://www.amazon.com/exec/obidos/ASIN/0321601912

Grails:  http://grails.org/

Get every new post delivered to your Inbox.


Content-Type: application/http; msgtype=response

WARC-Truncated: length

WARC-Type: response

text:
Posted tagged ‘YouTube’

12 Year Old Girl Beaten While Neighbor Films

March 28, 2012

A man who filmed a group of girls attacking a 12-year-old has told Providence, Rhode Island, police that he thought it was just a prank.

The man is not being charged and, according to police, is not involved in the case sinche te video is no longer in his possession. As I’m sure you can imagine, the girl’s mom has stated that she is horrified that the man didn’t try to stop her daughter’s attack.

From CNN:

Two of the girls have been charged with assault with a deadly weapon and conspiracy, and two others have been charged with simple assault and conspiracy, said Providence Police Sgt. Matthew Ryan.

The 12-year-old suffered two black eyes, a bruised nose and bite marks on her hands. Holly Gingerella, the girl’s mother, said, “My daughter is doing OK. She doesn’t look very good, but she’s a strong child.” She said her daughter has a shunt in her brain to aid with a medical problem, but the shunt was not damaged in the assault.

The man posted the video of the incident on YouTube, where he shows his face to the camera and describes the attack, “Kids are (expletive) sitting outside for like 20 minutes saying, ‘Don’t do this, don’t do that. You gotta keep going, you gotta keep fighting.’ They’re like planning it so they can just record it.” While he speaks, girls can be heard shouting in the background.

Mexico News Editor Found Decapitated

September 26, 2011

The editor of a Mexican newspaper was found dead, her body decapitated and with a note next to it.

Earlier this month, attackers left ominous threats mentioning two social media websites on signs beside mutilated bodies in northern Mexico. This appears to be yet another threat to journalists and citizens in Mexico who are reporting on cartel activities on social networking sites.

From CNN:

Maria Elizabeth Macias Castro, 39, was the editor in chief of the newspaper, Primera Hora.

Her body was found Saturday morning, according to the attorney general’s office in the northern Tamaulipas state. A message “attributed to a criminal group” was found next to her, the office said.

“The state government expresses its deepest condolences to the relatives and loved ones affected by these lamentable acts,” the office said, adding that it is investigating.

The Big Show Presents: An Introduction to Billy the Greek

July 24, 2011

…and now for the first time in 10 years…the return of “The Big Show”.

For your background, The Big Show was a radio program that appeared on KSUN 91.5 for more than 3 years featuring yours truly, “The Roaddawg Johnny Kreuz” along with my colleague and good friend “The Bad Ass Brett Anthony”.

The show came to an end back in May of 2001 but only recently have the tapes been discovered and put online for all of the world to hear. We always had a blast…that’s for sure!

Mind you, I did much of the writing for the show and created the many characters who appeared including “Billy the Greek” who became a weekly staple on the show. Let’s put it this way, he was created to be the prototypical “male chauvinist” and when you listen to the bits that he appeared on, you’d probably believe that the guy really acted this way in real life.

Anyways…here’s the first bit that I’m sharing. This was one of our very first episodes back in 1999 when we introduced Billy the Greek. As a disclaimer…most of the content on ALL of our broadcasts is for adult ears only as we do get a bit edgy/racy so listen at your own risk :)

For more videos/broadcasts, please click here.

Definitely better than a Casey Anthony radio program would have been :)

New Voice for the Aflac Duck

April 26, 2011

…and no it’s not Ben Affleck! It’s Dan McKeague, a 36-year-old father of three from suburban Minneapolis.

I’ll definitely miss Gilbert Gottfried and his voice. We’ll see if McKeague can fill his shoes!

From CNN Money:

McKeague, a sales manager at a local radio station with some experience doing voice overs, was one of the many hopeful celebrities, voice over artists and average Joes that submitted over 12,500 live and online auditions to provide the distinctive voice of the Aflac Duck.

In a video posted Tuesday on YouTube, the CEO of the Georgia-based company, Daniel Amos, and two other senior executives are shown offering the job to McKeague over the phone. McKeague, wearing a dark suit and tie, gratefully accepts the job from what appears to be his home.

If Everyone Gets a Chance…

February 10, 2011

…could you please click on this link to check out my latest blog post.

It’s not necessarily what you might be used to reading from me,  but I’d really appreciate it if you could just click the link and if you have any thoughts on the content, please leave a comment. :)

I Should Be in Pictures…

January 3, 2011

…or maybe just behind the camera writing/directing :)

Double Rainbow: What Does It Mean…

October 3, 2010

Boring Sunday nights mean watching classic videos like this!

Get every new post delivered to your Inbox.

Join 86 other followers

warcinfo:
robots: classic
hostname: ip-10-180-206-219.ec2.internal
software: Nutch 1.6 (CC)/CC WarcExport 1.0
isPartOf: CC-MAIN-2015-22
operator: CommonCrawl Admin
description: Wide crawl of the web for May 2015
publisher: CommonCrawl
format: WARC File Format 1.0
conformsTo: http://bibnum.bnf.fr/WARC/WARC_ISO_28500_version1_latestdraft.pdf


text:
School Libraries are more kitchen than groceries…Valenza

Joyce Valenza presentation…. it’s so tragic…

This video features school library guru Dr. Joyce Valenza on the topic of research (and the importance now, more than ever, of teacher-librarians). She discusses what research was like (process, sources, product, etc.) in 1988, 2005, and 2011 and brings the theme of environmental scans home so powerfully at the conclusion of the video.

Leave a comment

Filed under Education, Personal Learning Network, Presenters, School Library, Teacher Professional

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s


text:
Skip to content

On Saturday, July 26, The UC Davis Immigration Law Clinic and the UC Davis Immigration Law Alumni Council presented GULAG USA: Legal Challenges to Immigrant Detention, an MCLE on keeping immigrant clients or criminal defendants out of detention and protecting their rights while detained. National experts led a training program on the legal issues for this area of law for immigration and criminal practitioners. The program was from 8:30am to 2:30pm and offered 4.5 MCLE Units. The event was held at California Western School of Law in San Diego.

The program included 9 presenters. Their topics are identified below. You may link to the presenter's outline or power point of their presentation by clicking on the topic heading below.

  1. Panel One: Administrative (Immigration) remedies: Bond or Joseph hearings.
  2. Panel Two: Judicial remedies for immigration detention and conditions of confinement, Habeas Corpus, Bivens actions and attorney's fees.
  3. Panel Three : Litigation by the Federal Defenders of San Diego challenging post final removal order detention and prolonged detention.

Other Pertinent Resources:

A Legal Guide for INS Detainees published by the Commission on Immigration Policy, Practice and Pro Bono

Voice from Detention: A Report on Human Rights Violations at the Northwest Detention Center in Tacoma Washington

American Immigration Law Foundation, Practice Advisories

Attorneys Fees
Equal Access to Justice Act (EAJA) Fee Application (April 7, 2006) This Practice Advisory addresses the deadline for filing an Equal Access to Justice Act (EAJA) fee application, the statutory requirements for eligibility, and procedural aspects of filing an EAJA fee application, including documenting and calculating fees.

Introduction to Habeas Corpus (April 2006)
This is a short introduction to habeas corpus, addressing when and how a petition for habeas corpus can be used in the immigration context.

Arrest, Detention, and Bond Procedures for Noncitizens
Without Criminal Convictions (July 2008)
This practice advisory focuses on the law governing the arrest, detention and bond procedures for people present in the United States who do not have criminal convictions.

For more information, please contact our Alumni Relations office at 530.754.5326, or


text:
Dagger Falls

Daggers Falls is a large, stone walled town in the Daggerdale region of the Dalelands. The town is situated near a steep waterfall of the same name.

Dagger Falls Map

Click to enlarge.

Shadowdale Map

Notable events in campaign

This is where the adventure began. Home to Farmer Dylas and his family, this is where the gemblade was discovered.

Legend of the Gemblade slgonser


text:
LINGUIST List 12.457

Tue Feb 20 2001

Jobs: Comp Linguists in Munich, Germany

Editor for this issue: Michael Appleby <>

  1. Ms Anke Heublein, Comp Ling for SATZ Consulting GmbH, Munich, Germany

Message 1: Comp Ling for SATZ Consulting GmbH, Munich, Germany

Date: 20 Feb 2001 10:00:13 -0000
From: Ms Anke Heublein <>
Subject: Comp Ling for SATZ Consulting GmbH, Munich, Germany

Rank of Job:
Areas Required: Computer Linguists
Other Desired Areas:
University or Organization: SATZ Consulting GmbH
State or Province: Bavaria
Country: Germany
Final Date of Application: open
Contact: Ms Anke Heublein

Address for Applications:
Leopoldstr. 115
Bavaria 80804

SATZ Consulting is based in Munich, Germany and works together with
many different branches worldwide. In short: We undertake and organize
IT personnel for our global clients.

We are urgently looking for 3 computer linguists for a very exciting
customer based in downtown Munich.

Skills needed:

- University Degree in Computer Science or Computer Linguistics.
- Good prgramming knowledge in one or more of the following languages
such as C, C++, Perl or Java.
- Knowledge in at least one of the following: Parsing, Information
Retrieval and Extraction, Data Mining or Web Engineering

If you are interested, we would be happy to receive your full profile.

Best regards, Anke Heublein, Tel: +49(0)89-383862-37
Mail to author|Respond to list|Read more issues|LINGUIST home page|Top of issue


text:
LINGUIST List logo Eastern Michigan University Wayne State University *
* People & Organizations * Jobs * Calls & Conferences * Publications * Language Resources * Text & Computer Tools * Teaching & Learning * Mailing Lists * Search *
* *
LINGUIST List 18.2054

Sun Jul 08 2007

Confs: Translation/Poland

Editor for this issue: Jeremy Taylor <jeremylinguistlist.org>

To post to LINGUIST, use our convenient web form at http://linguistlist.org/LL/posttolinguist.html.
        1.    Andrzej Zaborski, Oriental Languages in Translation III

Message 1: Oriental Languages in Translation III
Date: 08-Jul-2007
From: Andrzej Zaborski <Zaborskilingua.filg.uj.edu.pl>
Subject: Oriental Languages in Translation III

Oriental Languages in Translation III
Short Title: OLT III

Date: 07-Apr-2008 - 08-Apr-2008
Location: Cracow, Poland
Contact: Marek Smurzynski
Contact Email: jmarek.smurzygazeta.pl

Linguistic Field(s): Translation

Meeting Description:

The focus of the conference will be on translation of poetry (first of all
Persian) but other topics like theory of translation and interpreting, teaching
of translation and interpreting, Bible translation etc. are welcome as well.

The Third Cracow Conference ''Oriental Languages in Translation'', like the two
previous ones, is aimed at the discussion of theoretical and practical problems
of translation especially from and into Oriental And African languages. The
present edition is dedicated to the memory of Wladyslaw Duleba, translator of
classical and modern Persian poetry into Polish. The deadline for proposals is
September 15th 2007. Full texts will be published in a conference volume but
the organizers will have right to have them evaluated by independent and
anonymous experts and to publish only those recommended for publication.

Respond to list|Read more issues|LINGUIST home page|Top of issue

Please report any bad links or misclassified data

LINGUIST Homepage | Read LINGUIST | Contact us

NSF Logo

While the LINGUIST List makes every effort to ensure the linguistic relevance of sites listed
on its pages, it cannot vouch for their contents.


text:
Publishing Partner: Cambridge University Press CUP Extra Publisher Login
amazon logo
More Info

Program Information

Program Name: International Doctoral Program in Linguistics
Alternate Name: LIPP
Program Homepage: http://www.lipp.lmu.de
Institution: Ludwig-Maximilians-Universität München
Address: Schellingstr. 10
City: Munich
Zip/Postal Code: 80799
Country: Germany
Application Deadline: June 01 and December 01
Contact Person: Daniel Holl, Dr.

click here to access email

Phone: +49 89 2180 3846
Fax: +49 89 2180 13990
Program Size: Large (over 25 students)
Program Description: The Ph.D. program LIPP 'Language Theory and Applied Linguistics' offers a research-oriented, well-structured and optimally supervised doctoral study program, which will lead to a Ph.D. within three years.
The interdisciplinary program comprises four modules approaching language from different perspectives:
- Language Phenomenology and Typology
- Empirical study of languages and its methodology
- Language and Society
- Language Theory and Language Modelling
The courses in the program are planned and taught by professors from the 12 participating disciplines; they are specialists in their field and represent a broad and interrelated spectrum of theoretical positions, methodological approaches and practical applications.
The program is interdisciplinary and focusses on linguistic theory as well as language use and their interrelation. Doctoral dissertations comprise studies from a general linguistic viewpoint, comparative approaches, the investigation of a specific language (synchronic or historic), as well as studies of texts and discourses with a view to their institutional context and the social significance and impact of their language.
One of LIPPs goals is to strengthen international cooperation and multi-lingualism among scholars. Highly qualified doctoral candidates from home and abroad are therefore especially encouraged to apply.
Add a new program
Update this program
Update a different program


text:
Package World for Reinstall

In you would like to rid the cruft on your system, or if you system has a virus (unlikely) or even if you want to install the system again at a later day a good way to do this is to package all your installed emerges. This can be done with a slightly-modified version of holla’s bash script:

# pkg-world

emerge -peq world | sed -n ‘s|^\[ebuild[^]]*\] \([^ $]\+\).*$|\1|p’ | \
sed -r ‘s/-[^-]+(-r[0-9]+)*$//’ | sort -u | while read pkg; do
for p in “${pkg}”; do
quickpkg –include-config=y –include-unmodified-config=y “$p”;

Once this is done you can backup your Gentoo system by:

tar –exclude=gentoo-backup.tgz -cvpzf gentoo-backup.tgz /etc /usr/portage /var/lib/portage/world

Obviously you might want to do more like /home and /root. Then you can extract the tar on a new stage3 and emerge -K --deep world. I’d recommend not trying this if too much time has passed between backup and reinstall as portage configurations may have changed, but otherwise it can save you alot of compiling time.

Please read the comments for other (easier) ways to do this.

About these ads

About Gen2ly

<3's linux

Posted on 2009-03-05, in Gentoo. Bookmark the permalink. 4 Comments.

  1. the following should do the same as above script:

    qlist -CISL | xargs quickpkg stuff

  2. Ah, good thinking. That’s what I love about linux, people eventually find an easier way to do things.

  3. quickpkg –include-config=y –include-unmodified-config=y $(eix -I –only-names)
    Package names don’t contain whitespaces per ebuild naming standard.
    Also, if you want to be on the safe side while not having to wait hours until your command completes you can just enable FEATURE=”buildpkg” and portage will do it for you when updating, push that to a backup server and next time your machine dies, restore will be über fast :)

  4. Didn’t know about that buildpkg feature, pretty cool. Also told viewers to read the comments as these are clearly a better way to do this. Thanks for the tip.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Get every new post delivered to your Inbox.

Join 58 other followers

%d bloggers like this:


text:
Qt2.2/KDE test packages available

Hi all :-)

Well, I broke down and installed an old egcs version on my machine and
started compiling KDE and Qt-based packages with it.  I'm going to be
uploading them to people.debian.org as I finish them and will try to keep
them current.

I'm holding off on uploading them to master, though, since they cannot be
built without going through some extraordinary steps and installing a
secondary (not available as a Debian package) compiler nor should apps
compiled with gcc 2.95.2 be linked against them (else, the dreaded
segfault may reappear).  Once we either update the compiler in Debian or I
manage to fix it with a backported patch, I'll upload fresh recompiles of
all Qt and KDE packages available.

In the meantime, though, I didn't want to alienate any users by not
offering them for general use (albeit unofficial).  So, if anyone wants to
keep up with the packages for woody, I've made the packages
apt'able.  Just add this line to your /etc/apt/sources.list:

deb http://people.debian.org/%7Echris/ woody/$(ARCH)/

And update your apt cache (apt-get update).  From then on, the packages
will be available via apt on your systems :-)  Unfortunately, I cannot
spare the drive space to do the same for potato right now (sorry to all
potato folks), but I will try to scavenge hardware eventually to rectify

Thanks!  And, if you run into any bugs, please DON'T file a bug report
since these packages are unofficial.  Unfortunately, I don't know jack
about Qt or KDE, so I may not be of much help either, but I'll try if the
problem is severe enough :-(

Reply to:


text:
Installation "bugs" in 1.2 - Report

Hi All!

Just got through installing the latest 1.2 system and found a small problem

When I got into the driver selection area (in particular the network card
listing) I found that the listing display was kind of screwed up.  The the
two columns often didn't match up properly.  The ID column was one off (down
screen) from the descriptions.  Kind of annoying but don't think it affected
proper installation.  This didn't happen in 1.1s installation.

I also had some problems with the response to the keyboard being jumpy.
Kind of a keyboard bounce problem where you get extra <enter>s.  Makes for
kind of a pain in the installation to say the least.  Think I had this
problem to some extent in the 1.1 installation too.

Probably a keyboard problem since it is a pretty old keyboard.  Then again
maybe not.  Thought I'd mention it none-the-less.

Labor can and will become its own employer through co-operative association.
- Leland Stanford

TO UNSUBSCRIBE FROM THIS MAILING LIST: e-mail the word "unsubscribe" to
debian-devel-REQUEST@lists.debian.org . Trouble? e-mail to Bruce@Pixar.com

Reply to:


text:
Re: Standardizing ~/.cache/ and similar things.

On Mon, Sep 19, 2005, Sylvain LE GALL wrote:

> I like your idea. But i think that i think it should be better
> to follow base-dir specification from freedesktop.org. It gives exactly
> the same kind of dirname, but in a more standardized way.
> Take a look at:
> http://www.freedesktop.org/wiki/Standards_2fbasedir_2dspec

   What about http://www.brynosaurus.com/cachedir/ also?

Reply to:


text:
Re: Starting services automatically after install

Aaron Toponce <aaron.toponce@gmail.com> writes:
> By default in Debian, when a service package is installed, such as
> openssh-server, or isc-dhcp-server, it starts the service. This seems
> counter-intuitive to me.

As you mentioned, this is a really old issue. I've documented my
personal solution at

It always prompts me to ask whether I want to start the service or not
when I install packages.

Reply to:


text:
Re: Debian and non-free

On Tue, Sep 16, 2008 at 11:24:18PM +0200, David Paleino wrote:
> On Tue, 16 Sep 2008 16:16:48 -0500, John Goerzen wrote:
> > On Mon, Sep 15, 2008 at 06:12:08PM +0200, David Paleino wrote:
> > No.  I agree with you, and actually proposed a General Resolution 8
> > years ago to get rid of non-free software:
> >
> > http://lists.debian.org/debian-devel/2000/06/msg00549.html
> > http://www.debian.org/vote/2000/vote_0008
> >

I seem to recall this earlier, in 1999 when RMS first raised this:

Vanity googling amacater and RMS revealed the thread, including comments
by Ian Lynagh.

The installer now does almost exactly what I asked then :)

Essentially, this has gone backwards and forwards for years. Although
David's wording is good, now is not the time - we need to get Lenny out.

gNewsense being based on Ubuntu (itself non-free from RMS' viewpoint)
seems just plain wrong to me - but that's me. It is notable that Mark
Shuttleworth has effectively ceased work on Gobuntu which is the Ubuntu

> Instead of removing non-free, I'd support the idea of non-free.org, and if that
> will make the FSF endorse us again, why not? :)
> Non-free is there just because the free counterparts aren't optimal. Someday
> these will, and non-free will just disappear from Debian :)

At this point, the pain of setting up parallel infrastructure and so on
will outweigh the gain. Situations with binary firmware blobs are
becoming better, though the path to full freedom is probably asymptotic

Andy - running GNU/Linux :)

Reply to:


text:
Re: Removing orphaned packages from testing

Paul Wise wrote:

> On Tue, Feb 17, 2009 at 11:18 AM, Barry deFreese <bdefreese@debian.org>
> wrote:
>> I'm struggling a little with this.
> Same.
> For example defoma has 113 rbdepends & 148 rdepends. Removing all of
> them would likely remove all fonts from Debian. I don't think it is
> acceptable to break testing this much.

If there are 148 packages there should be at least what, 20 maintainers? (I
would hope there are far more) why don't they, or the fonts team, adopt
defoma? or replace it with something else? 16 months of preparation of
squeeze should be more than enough time to do any of both options.

> Perhaps removing all the orphaned leaf packages would be a good start
> though.

Or finding an adopter.

Raphael Geissert - Debian Maintainer
www.debian.org - get.debian.net

Reply to:


text:
Re: Debian RAM supporting.

On Thu, 2 Apr 2009, Stefan Monnier wrote:

2. the response above indicates that yes, 4G (and maybe more) RAM can be
used with 32 bit CPU's and 32 bit OS, with (what I understand to be,
basically) a software patch to allow access to the memory that lies outside
the limits of a 32 bit OS, but using that patch has its own problems, and so

Atually, it's been part of the stock Linux kernel for years (probably
already in 2.4).  In Debian, you just need to install the
linux-image-<vers>-686-bigmem rather than linux-image-<vers>-686
package.  That's it.  No known compatibility issue.  The only "problems"
with it is that if you look under the hook, you may feel like it's a bit
of a hack, and also that in some micro benchmarks you may find such
kernels to be marginally slower.  No big deal, really.

In that case, as installation disks (I think) automatically sense the CPU, and install the appropriate kernel for the CPU, does an installation disk automatically find how much RAM a computer has, and then install the appropriate memory size based kernel?

Bret Busby
West Australia

"So once you do know what the question actually is,
 you'll know what the answer means."
- Deep Thought,
  Chapter 28 of Book 1 of
  "The Hitchhiker's Guide to the Galaxy:
  A Trilogy In Four Parts",
  written by Douglas Adams,
  published by Pan Books, 1992

Reply to:


text:
Re: Ready to vote on 2004-003?

Raul Miller <moth@debian.org> wrote:

> On Fri, May 21, 2004 at 11:48:26AM +0200, Frank Küster wrote:
>> There is at least one more, and it seems to me this is what many people
>> have expressed:
>>         * All data (everything) in main should be DFSG-free, and must be
>>           post-sarge. But we want an exception for sarge.
>>           The exception should be that stuff that can be distributed,
>>           but is non-free, and has been in sarge before the SC change,
>>           and would have been allowed to stay according to the old
>>           release policy, can stay in for sarge and point releases.
> ...
>> The question is not only how long you estimate that the changes that
>> still need to be made will take (e.g. for non-distributable things). The
>> main question, for me, is whether any of the so-far proposed resolutions[1]
>> achieves the goal of establishing an exception for sarge.
> Have you read http://www.debian.org/vote/2004/vote_004?

Yes, why do you ask?

> If it's too much to absorb all at once, as a first step you might want to
> go through it and read the paragraphs (and associated labels) that contain
> the word "Sarge".  [Then go back and read the rest with that mind.]

What do you want to say with that? I think that Proposal B, C and E want
to establish an exception as I wrote above. The point is that I feel
that Anthony does not read the same from those paragraphs. I wonder
why. But it seems it is no longer important, since he has (somehow)
answered the question.

>> It also tells me that I should keep on with my doubts whether the
>> desired effect, an exception for sarge, can be achieved with one of the
>> current proposals. Maybe Raul's can do that better.
> I've decided I do not need to make a proposal.  There is already a
> proposal which specifically talks about an exemption for Sarge.

My sentence was rather a suggestive question to Anthony, or the
like. Personally, I have the opinion that the proposals are well
formulated to achieve what (I believe) they want.

> I had forgotten about the part of the proposal which specifically provides
> for Sarge's release when I suggested that language.

You mean E. Proposal C also mentiones sarge, and I don't see how this
would not also establish such an exception.

Regards, Frank
Frank Küster, Biozentrum der Univ. Basel
Abt. Biophysikalische Chemie

Reply to:


text:
[bind10-dev] Sprint Administration and Task Lists

Stephen Morris stephen at isc.org
Mon Jan 17 14:33:24 UTC 2011

Following on from the meeting last week, I have updated the sprint task lists.

As agreed at the meeting, a sprint is now represented in Trac as a milestone with a set of Trac tasks associated with it.  Two milestones have been created, one for each of the A-Team and R-Team sprints:

* http://bind10.isc.org/milestone/A-Team-Sprint-20110126
* http://bind10.isc.org/milestone/R-Team-Sprint-20110125

(Click on the links ("active", "total" etc.) under the progress bar to see the list of tickets associated with the milestone.)

During the meeting we created tickets for the R-Team tasks for the remainder of Year 2 and associated them with the R-Team milestone.  To that I have added the outstanding tickets from the last R-Team sprint.  I have also been through the list of tasks we agreed for the A-Team for the remainder of Year 2 (including the statistics-related tasks), have created tickets for each of them, and have added these tickets to the A-Team milestone.  If you notice that anything has been missed, please create a task for it and add it to the appropriate milestone. (Also, if you think that a task description is insufficient or misleading, please add a comment to the ticket correcting it.)

Each task has had the estimate we agreed added to it.  This appears on the ticket as "Estimated number of hours".  Please ignore this label: the figure is the "scrum" estimate and is not the expected number of hours the task will take.  If, after completing a task, you think that the estimate was wrong you may correct it.  However if during a task it is evident that the task is more difficult than anticipated, it is preferred that you split the task and create additional tickets for it (attaching them to the milestone).

I have been through the results of the previous sprints (where estimates were made and where notes were made of which tasks were completed at the end of the sprint) and these are presented on the "Burndown" page (http://bind10.isc.org/wiki/Burndown).  I'm hoping that pre-creating tickets and using milestones will mean that the records are more complete in the future.

Concerning task assignment, when you select a task, please assign the ticket to yourself so that it is evident who is working on what task; assign it to "UnAssigned" when you want it reviewed.  Please give priority to outstanding reviews.  A task is not complete until it has been reviewed, merged into the master branch, and the ticket closed.  Until that happens, we must regard tasks as not being finished and can't count them as part of a sprint's output.

More information about the bind10-dev mailing list


text:
Shopizer-development --

About Shopizer-development
English (USA)

This mailing list is for Shopizer's developers

To see the collection of prior postings to the list, visit the Shopizer-development Archives.

Using Shopizer-development
To post a message to all the list members, send email to

You can subscribe to the list, or change your existing subscription, in the sections below.

Subscribing to Shopizer-development

Subscribe to Shopizer-development by filling out the following form. You will be sent email requesting confirmation, to prevent others from gratuitously subscribing you. This is a hidden list, which means that the list of members is available only to the list administrator.

    Your email address:
    Your name (optional):
    You may enter a privacy password below. This provides only mild security, but should prevent others from messing with your subscription. Do not use a valuable password as it will occasionally be emailed back to you in cleartext.

    If you choose not to enter a password, one will be automatically generated for you, and it will be sent to you once you've confirmed your subscription. You can always request a mail-back of your password when you edit your personal options.

    Pick a password:
    Reenter password to confirm:
    Which language do you prefer to display your messages? English (USA)
    Would you like to receive list mail batched in a daily digest? No Yes

Shopizer-development Subscribers
(The subscribers list is only available to the list administrator.)

Enter your admin address and password to visit the subscribers list:

Admin address: Password:

To unsubscribe from Shopizer-development, get a password reminder, or change your subscription options enter your subscription email address:

If you leave the field blank, you will be prompted for your email address

Shopizer-development list run by csamson777 at
Shopizer-development administrative interface (requires authorization)
Overview of all mailing lists
SlashdotMedia Privacy Statement

Delivered by Mailman
version 2.1.9
Python Powered GNU's Not Unix


text:
Seriously, WTF?

May 7, 2008 at 9:03 pm | Posted in Adoption, Books, Culture, entertainment, Film, Gothic Fiction | 10 Comments
Tags: , , , , , , , , , , ,

I am not a fan of Ellen Page.  Although I’m in the minority, I didn’t find her performance in Juno very realistic or endearing (I hate that I have even just linked to it’s Wikipedia page…).  People at work have attributed this to my age.  I thought perhaps my experience of adoption colored my views of the movie as well.  Certainly my experience is just that, my experience.  Still, even though Emma’s first mother firmly made her adoption plan early in the pregnancy, this was an emotional experience for her, her family, and for us.  There was no sarcasm or flippant jokes about her being irresponsible.  The only aspects of that movie I found close to ringing true were the scenes where she had to decide whether to continue her adoption plan and after the baby is born – and those were noteworthy only because she was actually acting, not just being herself.  They weren’t Oscar worthy.

Imagine my surprise when I ventured on to Pop Candy this evening before leaving work to discover that Ellen Page, who essentially played the same sarcastic young female character in Smart People, has been cast as Jane Eyre for a BBC Films production of all things!  Whitney, who loves Page, can’t even see her in this role.  Seriously, what are they thinking over there at BBC Films?  Jane Eyre doesn’t have a sarcastic bone in her body.  Do they have any expectation that Page can pull off ‘mousy’ or, more importantly, sincere?

I can’t say that I’ve ever seen a film or TV adaptation of Jane Eyre, but look at what is already out there.  What reason could there possibly be to cast Ellen Page in this role?  There is a 1944 version that stars Orson Welles, Joan Fontaine, and Elizabeth Taylor.  A&E produced a television starring Samantha Morton as Jane.  Who could really be more perfect than that?

I have no idea what really makes the film business tick.  I’m sure that I’ve misspent many an entertainment dollar in my life and am reaping this as my reward.  I would rather be struck blind like Mr. Rochester than even watch the trailer.

Create a free website or blog at | The Pool Theme.
Entries and comments feeds.

Get every new post delivered to your Inbox.


text:
March 9, 2013

Roberts adds GT offer on visit

Big corners are hard to find and Opelika (Ala.) defensive back Stephen Roberts fits that role perfectly and that is why schools like Alabama, Auburn, Florida State and now Georgia Tech have offered. Roberts got the good news from Yellow Jacket assistant Mike Pelton during his Junior Day visit in Atlanta on Saturday afternoon.

...More... To continue reading this article you must be a member. Sign Up Now!


text:
October 18, 2007

Jeanpierre, Brown win O-Line Sweepstakes

In South Carolina's version of 'Survivor,' Lemuel Jeanpierre and Seaver Brown have emerged with the top prize - a starting berth on the offensive line in Saturday's 12:30 p.m. game against Vanderbilt at Williams-Brice Stadium.

Brown, a redshirt freshman from Clearwater, Fla., will start at left guard, while Jeanpierre will line up at right guard when the Gamecocks face the Commodores in a key SEC contest.

"(Jeanpierre) looks pretty good on times," Spurrier said. "But if he'd been looking super, he's been playing all year right there. Sometimes, it finally clicks. Sometimes they start playing better. So, we just keep giving guys chances."

USC enters Saturday's game at No. 6 in the BCS standings behind Ohio State, South Florida,

Jeanpierre's selection is the most surprising considering the redshirt sophomore from Orlando, Fla. didn't play a single snap against Mississippi State and Kentucky, and just three snaps in last week's 21-15 victory at North Carolina.

...More... To continue reading this article you must be a member. Sign Up Now!