Chronos is one of the many Smalltalk-related blogs syndicated on Planet Smalltalk
χρόνος

Discussion of the Essence# programming language, and related issues and technologies.

Blog Timezone: America/Los_Angeles [Winter: -0800 hhmm | Summer: -0700 hhmm] 
Your local time:  
Showing posts with label Smalltalk. Show all posts
Showing posts with label Smalltalk. Show all posts

2009-03-16

Tirade: An Extensible Smalltalk Data Interchange Format

Göran Krampe has proposed (and implemented in Squeak) a generic, extensible data interchange format for Smalltalk. His initial use is limited to code delta streams, but the format actually defines a generic, extensible architecture that could be used to represent any sort of data.

I like it. I second the motion!


2009-03-12

2009 US Holidays

Most of the listed "holidays" will actually be business days, although some will not. The US Federal Holidays (on which most US Government offices will close, along with all Federally-chartered banks) are highlighted in bold. Generally, each business decides on its own which of these days (if any) will be non-business days (and for which employees):


Thu, 01 Jan 2009: NewYearsDay
Thu, 08 Jan 2009: JacksonDay
Mon, 19 Jan 2009: MartinLutherKingDay
Tue, 20 Jan 2009: InaugurationDay
Mon, 02 Feb 2009: GroundhogDay
Thu, 12 Feb 2009: LincolnsBirthday
Sat, 14 Feb 2009: ValentinesDay
Mon, 16 Feb 2009: WashingtonsBirthday
Tue, 17 Mar 2009: StPatricksDay
Wed, 01 Apr 2009: AprilFoolsDay
Fri, 10 Apr 2009: GoodFriday
Sun, 12 Apr 2009: Easter
Wed, 22 Apr 2009: EarthDay
Wed, 22 Apr 2009: AdministrativeAssistantsDay
Fri, 24 Apr 2009: ArborDay
Sun, 10 May 2009: MothersDay
Mon, 25 May 2009: MemorialDay
Sun, 14 Jun 2009: FlagDay
Sun, 21 Jun 2009: FathersDay
Sat, 04 Jul 2009: IndependenceDay
Sun, 26 Jul 2009: ParentsDay
Mon, 07 Sep 2009: LaborDay
Sun, 13 Sep 2009: GrandParentsDay
Mon, 12 Oct 2009: ColumbusDay
Sat, 24 Oct 2009: UnitedNationsDay
Sat, 31 Oct 2009: Halloween
Wed, 11 Nov 2009: VeteransDay
Thu, 26 Nov 2009: Thanksgiving
Fri, 27 Nov 2009: DayAfterThanksgiving
Thu, 24 Dec 2009: ChristmasEve
Fri, 25 Dec 2009: Christmas
Thu, 31 Dec 2009: NewYearsEve

The above list was generated by the Chronos Date/Time Library, using the following "do it":

| list |
list := SortedCollection sortBlock: [:a :b | a value < b value].
SemanticDatePolicy unitedStates
nominalAnnualEventOccurenceDatesInYear: 2009 do:
[:semanticKey :date | list add: semanticKey->date].
Transcript cr.
list do:
[:assoc |
Transcript
cr; show: (assoc value printStringUsing: #rfc2822);
show: ':'; tab; show: assoc key]


2008-12-09

Doing without

Reading a recent post by Ramon Leon, a thought occurred to me: In many cases, there's a better alternative to using #copyWithout:. The alternative would be to use #do:without:, implemeted as follows:

    do: block1 without: anElement
        self do: [:each | each = anElement ifFalse: [block1 value: each]]
The advantage should be obvious: It avoids making a "throw away" copy of the initial collection.

2008-03-25

Version 2008b of the Chronos Time Zone Repository has been published

Version 2008b of the Chronos Time Zone Repository has been published. It is based on version 2008b of the Olson Time Zone Database.

Downloads:




2008-03-23

Easter Dates From 2000 to 2020

Since it's Easter today (according to the rule for computing Easter established by Pope Gregory in the late sixteenth century,) I thought I would post the occurrence dates for Easter from 2000 to 2020 AD (Gregorian):

2000-04-23
2001-04-15
2002-03-31
2003-04-20
2004-04-11
2005-03-27
2006-04-16
2007-04-08
2008-03-23
2009-04-12
2010-04-04
2011-04-24
2012-04-08
2013-03-31
2014-04-20
2015-04-05
2016-03-27
2017-04-16
2018-04-01
2019-04-21
2020-04-12

And here's the Chronos code that computes the list above:

2000 to: 2020 
do: [:year |
Transcript
cr;
show: (GregorianEaster canonical inYear: year) printString]

Note, however, that not all Christians use the Gregorian calendar, or don't use Pope Gregory's rule for determining the date on which Easter occurs. Some still use the first "universal" Roman Catholic rule (which was established in 325 AD.) Before that, Easter was celebrated at various dates in different locales and cultures. Originally, it coincided with the day just before Passover (which is 14 Nisan in the Hebrew calendar, since Passover starts on 15 Nisan; also note that Hebrew calendar days start at sundown.)

2008-03-23 AD @ 12:55:09 pm -0700 [Gregorian]
0165-01-03 BE @ 12:55:09 pm -0700 [Bahai]
1724-07-14 AM @ 12:55:09 pm -0700 [Coptic]
2000-07-14 ZH @ 12:55:09 pm -0700 [Ethiopic]
5768-13-16 AM @ 12:55:09 pm -0700 [Hebrew]
1930-01-03 AS @ 12:55:09 pm -0700 [Indian Civil]
1429-03-15 AH @ 12:55:09 pm -0700 [Islamic (Fatimid)]
2008-03-10 AD @ 12:55:09 pm -0700 [Julian]
2761-03-10 AUC @ 12:55:09 pm -0700 [Julian (Imperial)]
1387-01-04 AP @ 12:55:09 pm -0700 [Persian]
6244-04-04 SY @ 12:55:09 pm -0700 [Solarian]
2008-083 @ 12:55:09 pm -0700 [Gregorian-ordinal date]
2008-W12-7 @ 12:55:09 pm -0700 [ISO]
J.D. 2454549 @ 12:55:09 pm -0700 [Julian Day]
39163:19:55:09.771325 days:hh:mm:ss.s.. since 1901-01-01T00:00:00Z (ST80 epoch)
1206302109 seconds since 1970-01-01T00:00:00Z (Unix epoch)
128507757097713250 100-nanosecond ticks since 1601-01-01T00:00:00Z (MS WIndows epoch)
Easter
weekend (Sunday)


2008-01-01

2007-12-31

2008 US Holidays

Most of the listed "holidays" will actually be business days, although some will not. The US Federal Holidays (on which most US Government offices will close, along with all Federally-chartered banks) are highlighted in bold. Generally, each business decides on its own which of these days (if any) will be non-business days (and for which employees):


Tue, 01 Jan 2008: NewYearsDay
Tue, 08 Jan 2008: JacksonDay
Mon, 21 Jan 2008: MartinLutherKingDay
Sat, 02 Feb 2008: GroundhogDay
Tue, 12 Feb 2008: LincolnsBirthday
Thu, 14 Feb 2008: ValentinesDay
Mon, 18 Feb 2008: WashingtonsBirthday
Mon, 17 Mar 2008: StPatricksDay
Fri, 21 Mar 2008: GoodFriday
Sun, 23 Mar 2008: Easter
Tue, 01 Apr 2008: AprilFoolsDay
Tue, 22 Apr 2008: EarthDay
Wed, 23 Apr 2008: AdministrativeAssistantsDay
Fri, 25 Apr 2008: ArborDay
Sun, 11 May 2008: MothersDay
Mon, 26 May 2008: MemorialDay
Sat, 14 Jun 2008: FlagDay
Sun, 15 Jun 2008: FathersDay
Fri, 04 Jul 2008: IndependenceDay
Sun, 27 Jul 2008: ParentsDay
Mon, 01 Sep 2008: LaborDay
Sun, 07 Sep 2008: GrandParentsDay
Mon, 13 Oct 2008: ColumbusDay
Fri, 24 Oct 2008: UnitedNationsDay
Fri, 31 Oct 2008: Halloween
Tue, 04 Nov 2008: ElectionDay
Tue, 11 Nov 2008: VeteransDay
Thu, 27 Nov 2008: Thanksgiving
Fri, 28 Nov 2008: DayAfterThanksgiving
Wed, 24 Dec 2008: ChristmasEve
Thu, 25 Dec 2008: Christmas
Wed, 31 Dec 2008: NewYearsEve

The above list was generated by the Chronos Date/Time Library, using the following "do it":

| list |
list := SortedCollection sortBlock: [:a :b | a value < b value].
SemanticDatePolicy unitedStates
nominalAnnualEventOccurenceDatesInYear: 2008 do:
[:semanticKey :date | list add: semanticKey->date].
Transcript cr.
list do:
[:assoc |
Transcript
cr; show: (assoc value printStringUsing: #rfc2822);
show: ':'; tab; show: assoc key]


Happy (Gregorian) New Year! (2008)

Timepoint now showInCommonWorldTimezones


Tue, 01 Jan 2008 13:55:54 +1300 (NZDT: Pacific/Auckland | New Zealand Time)
Tue, 01 Jan 2008 11:55:54 +1100 (EST: Australia/Sydney | AUS Eastern Time)
Tue, 01 Jan 2008 09:55:54 +0900 (JST: Asia/Tokyo | Tokyo Time)
Tue, 01 Jan 2008 09:55:54 +0900 (WST: Australia/Perth | W. Australia Time)
Tue, 01 Jan 2008 08:55:54 +0800 (HKT: Asia/Hong_Kong)
Tue, 01 Jan 2008 06:25:54 +0530 (IST: Asia/Calcutta | India Time)
Tue, 01 Jan 2008 03:55:54 +0300 (MSK: Europe/Moscow | Russian Time)
Tue, 01 Jan 2008 02:55:54 +0200 (IST: Asia/Jerusalem | Israel Time)
Tue, 01 Jan 2008 01:55:54 +0100 (CET: Europe/Amsterdam)
Tue, 01 Jan 2008 00:55:54 +0000 (GMT: Europe/London | London Time)
Tue, 01 Jan 2008 00:55:54 +0000 (UT: Universal Time)
Mon, 31 Dec 2007 22:55:54 -0200 (BRST: America/Sao_Paulo | E. South America Time)
Mon, 31 Dec 2007 21:55:54 -0300 (ART: America/Argentina/Buenos_Aires)
Mon, 31 Dec 2007 19:55:54 -0500 (EST: America/New_York | Eastern Time)
Mon, 31 Dec 2007 18:55:54 -0600 (CST: America/Chicago | Central Time)
Mon, 31 Dec 2007 17:55:54 -0700 (MST: America/Denver | Mountain Time)
Mon, 31 Dec 2007 16:55:54 -0800 (PST: America/Los_Angeles | Pacific Time)
Mon, 31 Dec 2007 14:55:54 -1000 (HST: Pacific/Honolulu | Hawaiian Time)


2007-12-25

Merry Christmas! (in Various Calendars)

Timepoint now showInAllCalendars
Local time is America/Los_Angeles ("Pacific Standard Time")—8 hours west of Universal Time


2007-12-25 AD @ 9:00:15 am -0800 [Gregorian]
0164-15-14 BE @ 9:00:15 am -0800 [Bahai]
1724-04-15 AM @ 9:00:15 am -0800 [Coptic]
2000-04-15 ZH @ 9:00:15 am -0800 [Ethiopic]
5768-10-16 AM @ 9:00:15 am -0800 [Hebrew]
1929-10-04 AS @ 9:00:15 am -0800 [Indian Civil]
1428-12-15 AH @ 9:00:15 am -0800 [Islamic (Fatimid)]
2007-12-12 AD @ 9:00:15 am -0800 [Julian]
2760-12-12 AUC @ 9:00:15 am -0800 [Julian (Imperial)]
1386-10-04 AP @ 9:00:15 am -0800 [Persian]
6244-01-04 SY @ 9:00:15 am -0800 [Solarian]
2007-359 @ 9:00:15 am -0800 [Gregorian-ordinal date]
2007-W52-2 @ 9:00:15 am -0800 [ISO]
J.D. 2454459 @ 9:00:15 am -0800 [Julian Day]
39074:17:00:15.077734 days:hh:mm:ss.s.. since 1901-01-01T00:00:00Z (ST80 epoch)
1198602015 seconds since 1970-01-01T00:00:00Z (Unix epoch)
128430756150777340 100-nanosecond ticks since 1601-01-01T00:00:00Z (MS WIndows epoch)
Christmas


2007-12-13

2007-12-11

Smalltalk in One Page

Both Travis Griggs and David Buck have recently published their contributions to the "Smalltalk in One Page" project. So I thought I'd provide my condensed specification of Smalltalk syntax (which is excerpted from my Smalltalk primer/tutorial, Smalltalk: Getting The Message):

Smalltalk Syntax: Formal Specification

Below is presented the full and complete formal specification of the syntax (grammar) of ANSI-Standard Smalltalk, using a metalanguage known as Extended Backus-Naur Formalism (EBNF). The specific flavor of EBNF syntax used is as specified by the ISO International Standard for EBNF.

The EBNF grammar of Smalltalk is presented as a list of numbered production rules. Note that there are only 67 production rules, that five of them simply define aliases (alternative names) solely for conceptual clarity, and that over half the production rules concern themselves with literal values, comments, identifiers and other low-level lexical constructs.

Formal EBNF Specification of Smalltalk Syntax

  1. Character = ? Any Unicode character ?;
  2. WhitespaceCharacter = ? Any space, newline or horizontal tab character ?;
  3. DecimalDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
  4. Letter = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M"
                    | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z"
                    | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m"
                    | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
  5. CommentCharacter = Character - '"';
            (* Any character other than a double quote *)
  6. Comment = '"', {CommentCharacter}, '"';
  7. OptionalWhitespace = {WhitespaceCharacter | Comment};
  8. Whitespace = (WhitespaceCharacter | Comment), OptionalWhitespace;
  9. LetterOrDigit =
                    DecimalDigit
                    | Letter;
  10. Identifier = (Letter | "_"), {(LetterOrDigit | "_")};
  11. Reference = Identifier;
  12. ConstantReference =
                    "nil"
                    | "false"
                    | "true";
  13. PseudoVariableReference =
                    "self"
                    | "super"
                    | "thisContext";
            (* "thisContext" is not defined by the ANSI Standard, but is widely used anyway *)
  14. ReservedIdentifier =
                    PseudoVariableReference
                    | ConstantReference;
  15. BindableIdentifier = Identifier - ReservedIdentifier;
  16. UnaryMessageSelector = Identifier;
  17. Keyword = Identifier, ":";
  18. KeywordMessageSelector = Keyword, {Keyword};
  19. BinarySelectorChar = "~" | "!" | "@" | "%" | "&" | "*" | "-" | "+" | "=" | "|" | "\" | "<" | ">" | "," | "?" | "/";
  20. BinaryMessageSelector = BinarySelectorChar, [BinarySelectorChar];

  21. IntegerLiteral = ["-"], UnsignedIntegerLiteral;
  22. UnsignedIntegerLiteral =
                    DecimalIntegerLiteral
                    | Radix, "r", BaseNIntegerLiteral;
  23. DecimalIntegerLiteral = DecimalDigit, {DecimalDigit};
  24. Radix = DecimalIntegerLiteral;
  25. BaseNIntegerLiteral = LetterOrDigit, {LetterOrDigit};
  26. ScaledDecimalLiteral = ["-"], DecimalIntegerLiteral, [".", DecimalIntegerLiteral], "s", [DecimalIntegerLiteral];
  27. FloatingPointLiteral = ["-"], DecimalIntegerLiteral, (".", DecimalIntegerLiteral, [Exponent] | Exponent);
  28. Exponent = ("e" | "d" | "q"), [["-"], DecimalIntegerLiteral];
  29. CharacterLiteral = "$", Character;
  30. StringLiteral = "'", {StringLiteralCharacter | "''"}, "'";
            (* To embed a "'" character in a String literal, use two consecutive single quotes *)
  31. StringLiteralCharacter = Character - "'";
            (* Any character other than a single quote *)
  32. SymbolInArrayLiteral =
                    UnaryMessageSelector - ConstantReference
                    | KeywordMessageSelector
                    | BinaryMessageSelector;
  33. SymbolLiteral = "#", (SymbolInArrayLiteral | ConstantReference | StringLiteral);
  34. ArrayLiteral =
                    ObjectArrayLiteral
                    | ByteArrayLiteral;
  35. ObjectArrayLiteral = "#", NestedObjectArrayLiteral;
  36. NestedObjectArrayLiteral = "(", OptionalWhitespace, [LiteralArrayElement, {Whitespace, LiteralArrayElement}], OptionalWhitespace, ")";
  37. LiteralArrayElement =
                    Literal - BlockLiteral
                    | NestedObjectArrayLiteral
                    | SymbolInArrayLiteral
                    | ConstantReference;
  38. ByteArrayLiteral = "#[", OptionalWhitespace, [UnsignedIntegerLiteral, {Whitespace, UnsignedIntegerLiteral}], OptionalWhitespace,"]";

  39. (* The preceding production rules would usually be handled by the lexical analyzer;
         the following production rules would usually be handled by the parser
    *)
  40. FormalBlockArgumentDeclaration = ":", BindableIdentifier;
  41. FormalBlockArgumentDeclarationList = FormalBlockArgumentDeclaration, {Whitespace, FormalBlockArgumentDeclaration};
  42. BlockLiteral = "[", [OptionalWhitespace, FormalBlockArgumentDeclarationList, OptionalWhitespace, "|"], ExecutableCode, OptionalWhitespace, "]";

  43. Literal = ConstantReference
                    | IntegerLiteral
                    | ScaledDecimalLiteral
                    | FloatingPointLiteral
                    | CharacterLiteral
                    | StringLiteral
                    | SymbolLiteral
                    | ArrayLiteral
                    | BlockLiteral;

  44. NestedExpression = "(", Statement, OptionalWhitespace, ")";
  45. Operand =
                    Literal
                    | Reference
                    | NestedExpression;

  46. UnaryMessage = UnaryMessageSelector;
  47. UnaryMessageChain = {OptionalWhitespace, UnaryMessage};
  48. BinaryMessageOperand = Operand, UnaryMessageChain;
  49. BinaryMessage = BinaryMessageSelector, OptionalWhitespace, BinaryMessageOperand;
  50. BinaryMessageChain = {OptionalWhitespace, BinaryMessage};
  51. KeywordMessageArgument = BinaryMessageOperand, BinaryMessageChain;
  52. KeywordMessageSegment = Keyword, OptionalWhitespace, KeywordMessageArgument;
  53. KeywordMessage = KeywordMessageSegment, {OptionalWhitespace, KeywordMessageSegment};
  54. MessageChain =
                    UnaryMessage, UnaryMessageChain, BinaryMessageChain, [KeywordMessage]
                    | BinaryMessage, BinaryMessageChain, [KeywordMessage]
                    | KeywordMessage;
  55. CascadedMessage = ";", OptionalWhitespace, MessageChain;
  56. Expression = Operand, [OptionalWhitespace, MessageChain, {OptionalWhitespace, CascadedMessage}];

  57. AssignmentOperation = OptionalWhitespace, BindableIdentifier, OptionalWhitespace, ":=";
  58. Statement = {AssignmentOperation}, OptionalWhitespace, Expression;
  59. MethodReturnOperator = OptionalWhitespace, "^";
  60. FinalStatement = [MethodReturnOperator], Statement;
  61. LocalVariableDeclarationList = OptionalWhitespace, "|", OptionalWhitespace, [BindableIdentifier, {Whitespace, BindableIdentifier}], OptionalWhitespace, "|";
  62. ExecutableCode = [LocalVariableDeclarationList], [{Statement, OptionalWhitespace, "."}, FinalStatement, ["."]];

  63. UnaryMethodHeader = UnaryMessageSelector;
  64. BinaryMethodHeader = BinaryMessageSelector, OptionalWhitespace, BindableIdentifier;
  65. KeywordMethodHeaderSegment = Keyword, OptionalWhitespace, BindableIdentifier;
  66. KeywordMethodHeader = KeywordMethodHeaderSegment, {Whitespace, KeywordMethodHeaderSegment};
  67. MethodHeader =
                    UnaryMethodHeader
                    | BinaryMethodHeader
                    | KeywordMethodHeader;
  68. MethodDeclaration = OptionalWhiteSpace, MethodHeader, ExecutableCode;

To resolve any ambiguities that may arise due to the absence of optional whitespace, lower-numbered production rules take precedence over higher-numbered production rules. The ambiguity issue is normally taken care of by having production rules 1 through 38 handled by the lexical analyzer, but having the remainder (production rules 39 through 67) handled by the parser.



When compiling a method declaraion, MethodDeclaration is the grammatical start symbol. When compiling executable code that's not a method definition, ExecutableCode is the start symbol (it's possible, for example, to select a section of a method's code in a code browser and execute it, without invoking the method itself; the same is true of the text of code comments, if they happen to contain valid Smalltalk code.)


2007-09-23

Smalltalk: Getting The Message

[Updated URL; referenced document was relocated]

I have written a Smalltalk primer/tutorial. It takes a different approach than other programming language primers or tutorials I have seen on the web.

Firstly, it does not assume that the reader knows the syntax of any particular programming language, although it does assume that the reader either knows how to program, or at least that he is comfortable with the relevant mathematics and foundational concepts.

Secondly, it first explains the computational model of Smalltalk, before presenting any Smalltalk syntax.

Thirdly, it takes a bottom-up approach to the presentation of Smalltalk syntax, starting with lexical tokens and ending with method declarations.

Finally, it stresses the importance of messages above all else, and shows how and why those who have attempted to copy Smalltalk in other programming languages failed to "get the message."

Constructive criticism, suggested rewordings to improve clarity, and requests that additional information be included or that additional topics be covered, are encouraged. Such requests should be sent to the author, Alan L. Lovejoy, at the following e-mail address: smalltalk-tutorial (at) alan-lovejoy (dot) net.

Enjoy!




Smalltalk: Getting The Message
The Essentials of Message-Oriented Programming with Smalltalk


About Smalltalk

Smalltalk is a foundational programming language that is based on pervasive message passing, pervasive dynamic and strong typing, pervasive reflection and pervasive object orientation.


Message passing: Almost all computation in Smalltalk happens via the sending of messages. The only way to invoke a method is to send a message—which necessarily involves dynamic binding (by name) of message to method at runtime (and never at compile time.) The internals of an object are not externally accessible, ever—the only way to access or modify an object's internal state is to send it a message. So function and data abstraction are both complete and universal. Pervasive message passing is Smalltalk's most important feature—a point that was lost on most of those who have tried to emulate Smalltalk when designing other programming languages.

Dynamic and strong typing: Although any object can be assigned to any variable, the only way to access or modify the internal state of an object is to send it a message—and the sending of any invalid message is detected and prevented at run time. So, even though Smalltalk's pervasive use of dynamic typing enables the programmer to define highly polymorphic abstractions with an extremely high degree of applicability and reusability, it is impossible to apply a function to a value for which there is no valid, defined behavior.

Reflection: In most programming languages, the specifications of types, classes, functions and subroutines exist only in the source code, and so are not accessible at runtime. But in Smalltalk, all specifications of all program constructs (classes, methods, etc.) are live objects that exist both at compile time and at runtime—and those objects are fully accessible to a running program, and can be queried or modified by sending them messages. So a Smalltalk program can not only fully introspect on itself, it has full power to change itself.

Object-orientation: In Smalltalk, all values are objects—even integers and other numbers, characters, strings, classes and blocks of code. Smalltalk is one of the first object-oriented programming languages. Its design was influenced by Lisp, Logo, Sketchpad, Flex and Simula. Smalltalk was developed as a research project at Xerox PARC in the 1970s by a team whose members included Dr. Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace and others.

Warning: Terms such as "object," "class," "type," "method" and hence "object-oriented programming" itself, as used in the context of Smalltalk, do not have the same meanings as they do when used in the context of other programming languages. The term object-oriented programming ("OOP") was coined by Dr. Alan Kay, the inventor of Smalltalk. He intended the term to describe the essential nature of Smalltalk. Unlike Smalltalk, most of the programming languages that market themselves as "object oriented" do not satisfy Dr. Kay's definition of object oriented programming:

"OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I'm not aware of them."

The full import of "object-oriented programming" as originally defined by Dr. Kay—and how and why the meaning of "OOP" as it applies to Smalltalk differs from the meaning of "OOP" as commonly understood outside of a Smalltalk context, is fully explained in the sections that follow. In addition, Dr. Kay's article "The Early History of Smalltalk" is highly recommended reading for anyone who wants to gain an even deeper insight into why and how Smalltalk came to be what it is, and why it is so different from the mainstream programming languages.

Continued...


2007-08-26

Chronos Time Zone Repository Version 2007g Published

Version 2007g of the Chronos Time Zone Repository has been published. It is based on version 2007g of the Olson Time Zone Database.

Downloads:




2007-06-05

Time Zone Boundary Divides University Campus

SOUTHERN Cross University (New South Wales, Australia) has a rather unique problem: They're establishing a new campus at the Gold Coast Airport Development Park, which will straddle the Queensland-NSW border on Crown land abutting the southern side of the Gold Coast Airport. New South Wales observes DST. Queensland does not.

Civil time will shift back and forth by an hour in NSW, but not in Queensland. So how will classes be scheduled? What about work schedules? Vice Chancellor Paul Clark said "We will probably be the guinea pigs in many ways because there's nowhere else in Australia with feet in two different states."

Now consider this question: How well would your software handle a case like this? Would your date/time library even be up to the task?


2007-05-16

How to market a dynamic programming language

The Ruby on Rails community has provided us with a canonical "how to" for marketing a dynamic programming language: Ruby on Rails vs Java.

Where's the Smalltalk version?


2007-04-29

About the version of Chronos distributed with VW 7.5...

VisualWorks 7.5 was released (finally!) a few days ago. For the first time, the Chronos Date/Time Library is included as a contributed component.

However, I would like to make everyone aware of the following points:


  • The version of Chronos that is on the CD (or that is available from the download page) is an ancient version from early January 2006 (more than a year ago.)

  • No Chronos parcels are included. Only the "Chronos.st" and "Chronos-Utilities.st" files are present (because back in January 2006, I wasn't distributing parcel files for Chronos.) I've been including parcels in the VisualWorks version of the Chronos download archive since March 2006.

I really recommend that, instead of using the version of Chronos that comes with VW 7.5, you either download the latest version of Chronos (Chronos Version B1.196), or else get the latest released version from the Cincom Public Store.


2007-04-02

Chronos Time Zone Repository Version 2007e Published

Version 2007e of the Chronos Time Zone Repository has been published. It is based on version 2007e of the Olson Time Zone Database.

Downloads:




2007-03-26

Chronos Time Zone Repository Version 2007d Published

Version 2007d of the Chronos Time Zone Repository has been published. It is based on version 2007d of the Olson Time Zone Database.

Downloads:




2007-03-12

2007 North American DST Changes: Resources & References (2)

Due to the changes at Planet Smalltalk, which have invalidated all URLs to old articles, and due to the fact that Google searches are still preferentially returning results to now-invalid URLs at Planet Smalltalk, I am republishing the following information:


The Chronos Date/Time Library has had the correct DST rules for North America since 2005-08-22 (a year and a half ago.)