Shame severs our relationship from God. It is so powerful that it often results in denial, apathy, and even a self-defensive wrath toward neighbor. At the same time, shame may drive us to discover the true source of our dignity beyond our isolated and broken self. The arc of the biblical narrative takes us from the fig leaves of Adam and Eve, who desire to hide from God and each other, to the liberation from self-consciousness that Jesus displays at the Last Supper, which can be seen as “undoing” the shame of Adam and Eve. Shame is the experience that can bring us close to the experience of the Cross, the place of simultaneous condemnation and liberation. By examining the biblical stories of shame and some personal and public stories of shame and of being shamed, Hirschfeld delves into this emotional and spiritual phenomenon to mine what shame has to teach. Shame cannot be erased, but God does not want us to be stuck in it. Working through our shame can lead us to a deeper sense of joy and freedom so we can, as the Proper Preface for Advent says, “without shame or fear rejoice to behold [Christ’s] appearing?”
A meditation and prayer companion for Christians who struggle with depression. The stigma around mental illness in our culture has had a damaging effect on those who suffer from its grip. As a priest and bishop, Hirschfeld has quietly and secretly been in treatment for depression for decades but now shares his own experience publicly. In this book, he offers short meditations, prayers, and suggestions of how one can follow and call upon Jesus for strength and peace during times of emotional upheaval. Christians often feel that their experience of depression or mental illness is a reflection of a deficit in their faith. As a result of seeing depression as a moral shortcoming or spiritual failure, we risk more damage to ourselves and even hurt those around us by denying what is really going on. This book, with its prayers and practical suggestions for spiritual and creative practices and resilience, can be a companion for those who suffer so that they may know more deeply the resilient love of Jesus.
New programming language designs are often evaluated on concrete implementations. However, in order to draw conclusions about the language design from the evaluation of concrete programming languages, these implementations need to be verified against the formalism of the design. To that end, we also have to ensure that the design actually meets its stated goals. A useful tool for the latter has been to create an executable semantics from a formalism that can execute a test suite of examples. However, this mechanism so far did not allow to verify an implementation against the design. Babelsberg is a new design for a family of object-constraint languages. Recently, we have developed a formal semantics to clarify some issues in the design of those languages. Supplementing this work, we report here on how this formalism is turned into an executable operational semantics using the RML system. Furthermore, we show how we extended the executable semantics to create a framework that can generate test suites for the concrete Babelsberg implementations that provide traceability from the design to the language. Finally, we discuss how these test suites helped us find and correct mistakes in the Babelsberg implementation for JavaScript.
Business process models are abstractions of concrete operational procedures that occur in the daily business of organizations. To cope with the complexity of these models, business process model abstraction has been introduced recently. Its goal is to derive from a detailed process model several abstract models that provide a high-level understanding of the process. While techniques for constructing abstract models are reported in the literature, little is known about the relationships between process instances and abstract models. In this paper we show how the state of an abstract activity can be calculated from the states of related, detailed process activities as they happen. The approach uses activity state propagation. With state uniqueness and state transition correctness we introduce formal properties that improve the understanding of state propagation. Algorithms to check these properties are devised. Finally, we use behavioral profiles to identify and classify behavioral inconsistencies in abstract process models that might occur, once activity state propagation is used.
Software development tools that work and behave consistently across different programming languages are helpful for developers, because they do not have to familiarize themselves with new tooling whenever they decide to use a new language. Also, being able to combine multiple programming languages in a program increases reusability, as developers do not have to recreate software frameworks and libraries in the language they develop in and can reuse existing software instead. However, developers often have a broad choice with regard to tools, some of which are designed for only one specific programming language. Various Integrated Development Environments have support for multiple languages, but are usually unable to provide a consistent programming experience due to different features of language runtimes. Furthermore, common mechanisms that allow reuse of software written in other languages usually use the operating system or a network connection as the abstract layer. Tools, however, often cannot support such indirections well and are therefore less useful in debugging scenarios for example. In this report, we present a novel approach that aims to improve the programming experience with regard to working with multiple high-level programming languages. As part of this approach, we reuse the tools of a Smalltalk programming environment for other languages and build a multi-language virtual execution environment which is able to provide the same runtime capabilities for all languages. The prototype system Squimera is an implementation of our approach and demonstrates that it is possible to reuse development tools, so that they behave in the same way across all supported programming languages. In addition, it provides convenient means to reuse and even mix software libraries and frameworks written in different languages without breaking the debugging experience.
Pattern matching is a well-established concept in the functional programming community. It provides the means for concisely identifying and destructuring values of interest. This enables a clean separation of data structures and respective functionality, as well as dispatching functionality based on more than a single value. Unfortunately, expressive pattern matching facilities are seldomly incorporated in present object-oriented programming languages. We present a seamless integration of pattern matching facilities in an object-oriented and dynamically typed programming language: Newspeak. We describe language extensions to improve the practicability and integrate our additions with the existing programming environment for Newspeak. This report is based on the first author’s master’s thesis.
When realizing a programming language as VM, implementing behavior as part of the VM, as primitive, usually results in reduced execution times. But supporting and developing primitive functions requires more effort than maintaining and using code in the hosted language since debugging is harder, and the turn-around times for VM parts are higher. Furthermore, source artifacts of primitive functions are seldom reused in new implementations of the same language. And if they are reused, the existing API usually is emulated, reducing the performance gains. Because of recent results in tracing dynamic compilation, the trade-off between performance and ease of implementation, reuse, and changeability might now be decided adversely. In this work, we investigate the trade-offs when creating primitives, and in particular how large a difference remains between primitive and hosted function run times in VMs with tracing just-in-time compiler. To that end, we implemented the algorithmic primitive BitBlt three times for RSqueak/VM. RSqueak/VM is a Smalltalk VM utilizing the PyPy RPython toolchain. We compare primitive implementations in C, RPython, and Smalltalk, showing that due to the tracing just-in-time compiler, the performance gap has lessened by one magnitude to one magnitude.
I am down to a pencil, a pen, and a bottle of ink. I hope one day to eliminate the pencil. Al Hirschfeld redefined caricature and exemplified Broadway and Hollywood, enchanting generations with his mastery of line. His art appeared in every major publication during nine decades of the twentieth and twenty-first centuries, as well as on numerous book, record, and program covers; film posters and publicity art; and on fifteen U.S. postage stamps. Now, The Hirschfeld Century brings together for the first time the artist’s extraordinary eighty-two-year career, revealed in more than 360 of his iconic black-and-white and color drawings, illustrations, and photographs—his influences, his techniques, his evolution from his earliest works to his last drawings, and with a biographical text by David Leopold, Hirschfeld authority, who, as archivist to the artist, worked side by side with him and has spent more than twenty years documenting the artist’s extraordinary output. Here is Hirschfeld at age seventeen, working in the publicity department at Goldwyn Pictures (1920–1921), rising from errand boy to artist; his year at Universal (1921); and, beginning at age eighteen, art director at Selznick Pictures, headed by Louis Selznick (father of David O.) in New York. We see Hirschfeld, at age twenty-one, being influenced by the stylized drawings of Miguel Covarrubias, newly arrived from Mexico (they shared a studio on West Forty-Second Street), whose caricatures appeared in many of the most influential magazines, among them Vanity Fair. We see, as well, how Hirschfeld’s friendship with John Held Jr. (Held’s drawings literally created the look of the Jazz Age) was just as central as Covarrubias to the young artist’s development, how Held’s thin line affected Hirschfeld’s early caricatures. Here is the Hirschfeld century, from his early doodles on the backs of theater programs in 1926 that led to his work for the drama editors of the New York Herald Tribune (an association that lasted twenty years) to his receiving a telegram from The New York Times, in 1928, asking for a two-column drawing of Sir Harry Lauder, a Scottish vaudeville singing sensation making one of his (many) farewell tours, an assignment that began a collaboration with the Times that lasted seventy-five years, to Hirschfeld’s theater caricatures, by age twenty-five, a drawing appearing every week in one of four different New York newspapers. Here, through Hirschfeld’s pen, are Ethel Merman, Benny Goodman, Judy Garland, Mickey Rooney, Katharine Hepburn, the Marx Brothers, Barbra Streisand, Elia Kazan, Mick Jagger, Ella Fitzgerald, Laurence Olivier, Martha Graham, et al. . . . Among the productions featured: Fiddler on the Roof, West Side Story, Rent, Guys and Dolls, The Wizard of Oz (Hirschfeld drew five posters for the original release), Gone with the Wind, The Sopranos, and more. Here as well are his brilliant portraits of writers, politicians, and the like, among them Ernest Hemingway (a pal from 1920s Paris), Tom Wolfe, Charles de Gaulle, Nelson Mandela, Joseph Stalin, Winston Churchill, and every president from Franklin D. Roosevelt to Bill Clinton. Sumptuous and ambitious, a book that gives us, through images and text, a Hirschfeld portrait of an artist and his age.
Defining Graphical User Interfaces (GUIs) through functional abstractions can reduce the complexity that arises from mutable abstractions. Recent examples, such as Facebook's React GUI framework have shown, how modelling the view as a functional projection from the application state to a visual representation can reduce the number of interacting objects and thus help to improve the reliabiliy of the system. This however comes at the price of a more rigid, functional framework where programmers are forced to express visual entities with functional abstractions, detached from the way one intuitively thinks about the physical world. In contrast to that, the GUI Framework Morphic allows interactions in the graphical domain, such as grabbing, dragging or resizing of elements to evolve an application at runtime, providing liveness and directness in the development workflow. Modelling each visual entity through mutable abstractions however makes it difficult to ensure correctness when GUIs start to grow more complex. Furthermore, by evolving morphs at runtime through direct manipulation we diverge more and more from the symbolic description that corresponds to the morph. Given that both of these approaches have their merits and problems, is there a way to combine them in a meaningful way that preserves their respective benefits? As a solution for this problem, we propose to lift Morphic's concept of direct manipulation from the mutation of state to the transformation of source code. In particular, we will explore the design, implementation and integration of a bidirectional mapping between the graphical representation and a functional and declarative symbolic description of a graphical user interface within a self hosted development environment. We will present Transmorphic, a functional take on the Morphic GUI Framework, where the visual and structural properties of morphs are defined in a purely functional, declarative fashion. In Transmorphic, the developer is able to assemble different morphs at runtime through direct manipulation which is automatically translated into changes in the code of the application. In this way, the comprehensiveness and predictability of direct manipulation can be used in the context of a purely functional GUI, while the effects of the manipulation are reflected in a medium that is always in reach for the programmer and can even be used to incorporate the source transformations into the source files of the application.
Complexity in software systems is a major factor driving development and maintenance costs. To master this complexity, software is divided into modules that can be developed and tested separately. In order to support this separation of modules, each module should provide a clean and concise public interface. Therefore, the ability to selectively hide functionality using access control is an important feature in a programming language intended for complex software systems. Software systems are increasingly distributed, adding not only to their inherent complexity, but also presenting security challenges. The object-capability approach addresses these challenges by defining language properties providing only minimal capabilities to objects. One programming language that is based on the object-capability approach is Newspeak, a dynamic programming language designed for modularity and security. The Newspeak specification describes access control as one of Newspeak’s properties, because it is a requirement for the object-capability approach. However, access control, as defined in the Newspeak specification, is currently not enforced in its implementation. This work introduces an access control implementation for Newspeak, enabling the security of object-capabilities and enhancing modularity. We describe our implementation of access control for Newspeak. We adapted the runtime environment, the reflective system, the compiler toolchain, and the virtual machine. Finally, we describe a migration strategy for the existing Newspeak code base, so that our access control implementation can be integrated with minimal effort.
Developing large software projects is a complicated task and can be demanding for developers. Continuous integration is common practice for reducing complexity. By integrating and testing changes often, changesets are kept small and therefore easily comprehensible. Travis CI is a service that offers continuous integration and continuous deployment in the cloud. Software projects are build, tested, and deployed using the Travis CI infrastructure without interrupting the development process. This report describes how Travis CI works, presents how time-driven, periodic building is implemented as well as how CI data visualization can be done, and proposes a way of dealing with dependency problems.
Version Control Systems (VCS) allow developers to manage changes to software artifacts. Developers interact with VCSs through a variety of client programs, such as graphical front-ends or command line tools. It is desirable to use the same version control client program against different VCSs. Unfortunately, no established abstraction over VCS concepts exists. Instead, VCS client programs implement ad-hoc solutions to support interaction with multiple VCSs. This thesis presents Pur, an abstraction over version control concepts that allows building rich client programs that can interact with multiple VCSs. We provide an implementation of this abstraction and validate it by implementing a client application.
This volume covers many topics, including number theory, Boolean functions, combinatorial geometry, and algorithms over finite fields. It contains many new, theoretical and applicable results, as well as surveys that were presented by the top specialists in these areas. New results include an answer to one of Serre''s questions, posted in a letter to Top; cryptographic applications of the discrete logarithm problem related to elliptic curves and hyperelliptic curves; construction of function field towers; construction of new classes of Boolean cryptographic functions; and algorithmic applications of algebraic geometry. Sample Chapter(s). Chapter 1: Fast addition on non-hyperelliptic genus 3 curves (424 KB). Contents: Symmetric Cryptography and Algebraic Curves (F Voloch); Galois Invariant Smoothness Basis (J-M Couveignes & R Lercier); Fuzzy Pairing-Based CL-PKC (M Kiviharju); On the Semiprimitivity of Cyclic Codes (Y Aubry & P Langevin); Decoding of Scroll Codes (G H Hitching & T Johnsen); An Optimal Unramified Tower of Function Fields (K Brander); On the Number of Resilient Boolean Functions (S Mesnager); On Quadratic Extensions of Cyclic Projective Planes (H F Law & P P W Wong); Partitions of Vector Spaces over Finite Fields (Y Zelenyuk); and other papers. Readership: Mathematicians, researchers in mathematics (academic and industry R&D).
Program behavior that relies on contextual information, such as physical location or network accessibility, is common in today's applications, yet its representation is not sufficiently supported by programming languages. With context-oriented programming (COP), such context-dependent behavioral variations can be explicitly modularized and dynamically activated. In general, COP could be used to manage any context-specific behavior. However, its contemporary realizations limit the control of dynamic adaptation. This, in turn, limits the interaction of COP's adaptation mechanisms with widely used architectures, such as event-based, mobile, and distributed programming. The JCop programming language extends Java with language constructs for context-oriented programming and additionally provides a domain-specific aspect language for declarative control over runtime adaptations. As a result, these redesigned implementations are more concise and better modularized than their counterparts using plain COP. JCop's main features have been described in our previous publications. However, a complete language specification has not been presented so far. This report presents the entire JCop language including the syntax and semantics of its new language constructs.
This illustrated book vividly depicts the most threatened birds on Earth. It provides up-to-date information from BirdLife International on the threats each species faces, and the measures being taken to save them. Today, 590 birds species are classified as Endangered or Critically Endangered, or now only exist in captivity. This landmark publication features stunning photographs of 515 of these species--including the results of a prestigious international photographic competition organized specificallyfor this book. This is the first time that images of many of these birds have been published. It also showcases meticulously accurate illustrations by acclaimed wildlife artist Tomasz Cofta for the 75 speciies of which no photographs are known to exist.
Thank you for visiting our website. Would you like to provide feedback on how we could improve your experience?
This site does not use any third party cookies with one exception — it uses cookies from Google to deliver its services and to analyze traffic.Learn More.