Cool can come from what a [thing] is or what it does. But at the core, Cool is about purity of expression, of material objects being infused with human energy, creativity and insight to make them more than just the sum of their parts.

– Mark Hoyer, WHAT IS COOL?, Cycle World 2/2010

I love Mark’s take on cool; from motorcycles to programming languages, it still makes sense. It makes me think about how great it is to be alive, living, in the present. It is a gift.

I’ve [Joe Marshall] added `keyword’ objects to MIT Scheme in a way that I hope keeps everyone happy. A keyword is a self-evaluating symbolic token, much like a symbol, but it never needs quoting because it can never mean anything but itself.

The reading and printing of keywords is controlled by the variable *keyword-style*, which can be #f or one of these symbols: cl, dsssl, srfi-88, both

If *keyword-style* is #F (the default), then there is no way to read keywords, and they are printed as #[keyword foo].

If *keyword-style* is ‘cl, then tokens with a leading colon are considered keywords and keywords are printed with a leading colon. Symbols with a leading colon are printed with vertical-bar quotes
and you can create symbols with leading colons by using vertical-bar quotes.

If *keyword-style* is ’srfi-88, then tokens with a trailing colon are considered keywords and keywords are printed with a trailing colon. Symbols with a trailing colon are printed with vertical-bar quotes and you can create symbols with trailing colons by using vertical-bar quotes.

‘dsssl is a synonym for ’srfi-88

If *keyword-style* is ‘both, then either syntax is acceptable for reading, but the cl syntax will be used in printing. (Putting a colon on both ends would be weird, so don’t.)

(via MIT-Scheme-devel)

Windows allows you to execute programs with another user’s credentials. You are probability thinking “Simple right?”. Well, it isn’t. Using this feature seems to consistently corrupt the RunAs-ed user’s profile. Corrupted profiles seem to be a mysterious thing with little to no way to fix them; creating a new profile is basically the only solution. In my case I restored from a nightly backup (because I know stuff like this is bound to happen on Windows). My takeaway:

Disable RunAs on Windows!

Here is how.

(via Got Emacs?)

Both of the programs depend on the GL and GLUT libraries. At runtime the correct DLL is loaded depending on the OS type. There wasn’t a setting for Cygwin so I added one. The thing was that I specified the wrong file name: /usr/lib/libGL.dll.a and /usr/lib/libglut.dll.a.

It was an uneducated guess in the first place. I figured there would be a one to one mapping. After Marco kindly kicked my butt on the Ikarus list though, by asking some basic questions like has it ever worked and have I checked out the difference in error messages, I got me thinking that I should have read up on this.

The Cygwin documentation here and the Redhat documentation here seem to explain it… Windows DLLs need additional information to be linked against. On Cygwin, when GCC sees .dll.a files it “knows” how to get the additional data out of them in case you want to link to Win32. Reading on in the Redhat documentation, it lists the DLL search path when you specify -L argument for GCC. In that list I saw that /bin is included. That surprised me.

It turns out that on Cygwin, DLLs that are not compiled to work with Win32 are located there. At least, this is my understanding. When you link to these DLLs though, the OpenGL demos work just fine on Cygwin with Ikarus.

Is this also your understanding? I need to dig in more to this topic.

I had been trying to get so many things working this weekend that I didn’t invest the amount of the time that this deserved, or most of those things for that matter.

Via the homepage:

The 4th ACM International Conference on Distributed Event-Based Systems (DEBS) builds on the success of first three editions from 2007. DEBS Conference success is rooted in five editions of the DEBS workshops held from 2002 to 2006 in companion with major conferences such as ICDCS, ICSE, and SIGMOD/PODS. The conference has received full ACM sponsorship since 2009.

The objectives of the DEBS Conference are to provide a forum dedicated to the dissemination of original research, the discussion of practical insights, and the reporting on relevant experience relating to event-based computing that was previously scattered across several scientific and professional communities. The conference also aims at providing a forum for academia and industry to exchange ideas, for example, through industry papers and demo papers.

Via caml-list:

--------------------------------------------------------------------------

Event-based systems are rapidly gaining importance in many application
domains ranging from real time monitoring systems in production, logistics
and networking to complex event processing in finance and security. The
event based paradigm has gathered momentum as witnessed by current efforts
in areas including event-driven architectures, complex event processing,
business process management and modelling, Grid computing, Web services
notifications, information dissemination, event stream processing, and
message-oriented middleware. The various communities dealing with event
based systems have made progress in different aspects of the problem. The
DEBS conference attempts to bring together researchers and practitioners
active in the various subcommunities to share their views and reach a
common understanding.

The scope of the conference covers all topics relevant to event-based
computing ranging from those discussed in related disciplines (e.g.,
coordination, software engineering, peer-to-peer systems, Grid computing,
and streaming databases), over domain-specific topics of event-based
computing (e.g., workflow management systems, mobile computing, pervasive
and ubiquitous computing, sensor networks, user interfaces, component
integration, Web services, and embedded systems), to enterprise related
topics (e.g., complex event detection, enterprise application integration,
real time enterprises, and Web services notifications).

The topics addressed by the conference include (but are not limited to):

Models, Architectures and Paradigms
- Event-driven architectures
- Basic interaction models
- Event algebras, event schemas and type systems
- Languages for event correlation and patterns, streaming and continuous
  queries, data fusion
- Models for static and dynamic environments
- Complex event processing
- Design and programming methodologies
- Event-based business process management and modeling
- Experimental methodologies
- Performance modeling and prediction based on analytic approaches

Middleware Infrastructures for Event-Based Computing
- Federated event-based systems
- Middleware for actuator and sensor networks
- Algorithms and protocols
- Event dissemination based on p2p systems
- Context and location awareness
- Fault-tolerance, reliability, availability, and recovery
- Security issues
- (Self-)Management
- Mobility and resource constrained device support
- Streaming queries, transformations, or correlation engines

Applications, Experiences, and Requirements
- Use cases and applications of event-based systems
- Real-world application deployments using event-based middleware
- Domain-specific deployments of event-based systems
- Real-world data characterising event-based applications
- Benchmarks, performance evaluations, and testbeds
- Application requirements for next-generation event-based solutions
- Relation to other architectures
- Enterprise application integration
- Event-driven business process management
- Information logistics
- Seamless integration of event-based mechanisms into middleware
  platforms

having or showing skill, cleverness, or resourcefulness in handling situations <an adroit leader> <adroit maneuvers>

lucubration:

laborious or intensive study; also : the product of such study —usually used in plural

(via Merrian Webster (here and here) via PLT via Parnell)

They live here: russian-string-constants.ss and ukrainian-string-constants.ss.