Enterprise Pharo a Web Perspective

Enterprise Pharo: A Web Perspective, by Damien Cassou, Stéphane Ducasse, Luc Fabresse, Johan Fabry, and Sven Van Caekenberghe, connects Pharo with Web applications and supporting libraries. This guide follows the October 6, 2016 PDF and all sixteen chapters across five parts. The libraries and deployment examples belong to that historical environment; record compatibility adaptations separately when experimenting with a later image or package release.

Chapter-by-chapter summaries

Chapter 1: Teapot

Teapot introduces a compact route from an HTTP request to application behavior. Map a route to the code handling it and examine how a response is constructed. A small example helps distinguish framework convenience from the underlying request–response exchange. Make inputs and expected outputs explicit before extending the application.

Chapter 2: A Small Web Application

Building and deploying a small application connects isolated route examples into a usable service. Track state, request handling, and the environment in which the program runs. A successful local request is one checkpoint rather than the complete deployment story. Recreate the example from recorded setup steps to expose hidden dependencies.

Chapter 3: Character Encoding and Resource Description

Characters, bytes, and metadata about a resource must be distinguished. An encoding determines how text becomes bytes and how those bytes are interpreted again. A response can contain valid bytes yet display the wrong text when the interpretation differs. Test a round trip with nontrivial characters and inspect the declared metadata.

Chapter 4: Zinc HTTP Client

The client chapter develops making requests and interpreting responses. A status, header, and body provide different information and should not be collapsed into the returned text alone. Follow how a request is configured and how unexpected responses are handled. Keep transport success distinct from an application-level result that actually answers the request.

Chapter 5: Zinc HTTP Server

The server receives requests and dispatches behavior that constructs responses. Trace the boundaries between network handling, application decisions, and representation. Test malformed or unexpected input as well as the happy path. The chapter’s framework makes implementation easier, but the application still needs an explicit account of what each endpoint accepts and returns.

Chapter 6: WebSockets

WebSockets support a continuing bidirectional connection rather than a series of independent ordinary responses. That changes how state, messages, and connection lifecycle must be considered. Identify when a message is complete and what happens after disconnection. A working exchange should be understood as part of a continuing protocol, not just a successful one-time callback.

Chapter 7: NeoCSV

CSV processing translates tabular text into application data and back. Delimiters, quoting, types, and record boundaries matter because a visually simple file can contain structural ambiguity. Define the expected columns and inspect the imported values. A successful parse does not establish that the data’s units or categories match the application’s assumptions.

Chapter 8: NeoJSON

JSON provides a structured interchange representation whose values must be mapped appropriately into Pharo objects. Distinguish valid JSON from data that satisfies the application’s expected structure. Check optional, missing, and differently typed values. Serialization is an agreement about representation; it does not automatically preserve every detail of an arbitrary runtime object graph.

Chapter 9: STON

Smalltalk Object Notation provides a representation suited to Smalltalk data and objects. Compare its purposes with the more general interchange role of JSON. Follow what information is encoded and how it is reconstructed. Choose a format according to the intended readers and compatibility needs rather than the shortest output for one example.

Chapter 10: Fuel

Fuel addresses serialization of complex objects. Object relationships, identity, and the reconstruction environment matter beyond the printed value of an isolated object. A round-trip experiment should inspect relationships as well as content. Keep a saved object graph distinct from a portable, long-term public data contract whose requirements may differ.

Chapter 11: Voyage

Voyage introduces persistence so application objects can survive beyond one immediate execution context. Identify what is stored, when changes become persistent, and how objects are retrieved. Test the application after a fresh start rather than rely on objects still present in memory. Persistence decisions should follow the application’s lifecycle and consistency needs.

Chapter 12: Mustache Templates

Templates separate presentation structure from values supplied by application code. Follow how the context provides data and how missing or repeated values affect rendering. A clean separation makes each part easier to understand, but the boundary must be real rather than a template filled with unexplained business decisions.

Chapter 13: RenoirSt

RenoirSt provides a Pharo-oriented way to work with cascading style sheets. Distinguish the generated styling from the document structure it targets. A style rule works through selector matching and precedence, not merely the order in which a developer thinks of it. Inspect the resulting CSS and explain why it affects the intended element.

Chapter 14: Pillar

Pillar supports structured documentation and presentation output. Source structure makes it possible to transform a document into different forms while retaining its organization. Keep content, markup, and rendering decisions distinct. Test headings, links, and a representative complex element rather than assume a successful simple paragraph establishes complete output compatibility.

Chapter 15: Artefact

Artefact generates PDF documents through programmatic layout and content. A PDF output must be checked visually as well as generated without an error. Trace how dimensions, placement, and repeated elements contribute to the final page. Separate the application’s data from document-specific layout decisions so an update does not require rewriting unrelated logic.

Chapter 16: Production Deployment

The final chapter connects application code with a running production environment. Availability, configuration, process lifecycle, and supporting infrastructure become part of the system’s behavior. Follow the historical example to understand responsibilities, then check current requirements before real deployment. Reproducibility matters: document how another person could start, verify, update, and diagnose the service.

Study instructions

1. Record the image and package versions used for every example.
2. Build one small request–response application and extend it as the chapters introduce data and presentation.
3. Test serialization through a round trip and inspect types, identity, or relationships appropriate to the format.
4. Check generated HTML, CSS, and PDF outputs rather than rely only on successful execution.
5. Document a clean-start procedure that reconstructs the application and its persistent data.
6. Keep the 2016 deployment lesson separate from current operational instructions.

Questions for reflection

• What information is lost or transformed when an object becomes an interchange format?
• Which responsibilities belong to HTTP handling and which to the application?
• What does a fresh-start test reveal that an existing development image can conceal?

Sources and coverage

This original study guide follows the complete linked source edition and all of its substantive chapters or named teaching sections. It condenses their main ideas and relationships; the study tasks are guidance for reading alongside the complete resource. It does not reproduce the source exercises or answer key. Book source; Complete source PDF.