Change search
Refine search result
1 - 34 of 34
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1.
    Björklund, Thomas
    et al.
    Luleå tekniska universitet.
    Brodnik, Andrej
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Formal verification of a trie-based data structure2005Conference paper (Refereed)
  • 2. Carlsson, Magnus
    et al.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Kieburtz, Dick
    Oregon Health & Science University.
    The semantic layers of Timber2003In: Programming languages and systems: first Asian Symposium, Beijing, China, November 27-29, 2003 ; proceedings / [ed] Atsushi Ohori, Encyclopedia of Global Archaeology/Springer Verlag, 2003, p. 339-356Conference paper (Refereed)
    Abstract [en]

    We present a three-layered semantics of Timber, a language designed for programming real-time systems in a reactive, object-oriented style. The innermost layer amounts to a traditional deterministic, pure, functional language, around which we formulate a middle layer of concurrent objects, in terms of a monadic transition semantics. The outermost layer, where the language is married to deadline-driven scheduling theory, is where we define message ordering and CPU allocation to actions. Our main contributions are a formalized notion of a time-constrained reaction, and a demonstration of how scheduling theory, process calculii, and the lambda calculus can be jointly applied to obtain a direct and succinct semantics of a complex, real-world programming language with well-defined real-time behavior.

  • 3.
    Feiertag, Nico
    et al.
    Symtavision Gmbh.
    Richter, Kai
    Symtavision Gmbh.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Jonsson, Jan
    Chalmers University of Technology.
    A compositional framework for end-to-end path delay calculation of automotive systems under different path semantics2009In: Real-Time Systems Symposium, 2008: RTSS 2008 ; Nov. 30, 2008 - Dec. 3, 2008, Barcelona, Spain ; proceedings, Piscataway, NJ: IEEE Communications Society, 2009Conference paper (Refereed)
    Abstract [en]

    While the real-time systems community has developed very valuable approaches to timing and scheduling analysis for processors and buses over the last four decades, another very relevant issue has received only limited attention: end-to-end timing. Most of the known work poses restrictions on specific task activation and communication mechanisms, e.g. unbounded FIFO queues along event-triggered paths. In automotive systems, however, register buffers and periodic sampling are far more common. In this paper, we present a formal framework for the calculation of end-to-end latencies in multi-rate, register-based systems. We show that in systems with sampling, analysis must distinguish between different "meanings" of end-to-end timing. For instance, control engineers are mostly concerned with the "maximum age of data", i.e. the worst-case timing of the latest possible signal. In body electronics, the "first reaction" is key, i.e. worst-case timing of the earliest possible signal. Because the analysis of either case can be different, a clear distinction is mandatory. This paper gives examples and introduces the notion of such end-to-end timing semantics, thereby considering the specific mechanisms and effects typically found in automotive execution platforms such as over- and under-sampling and jitter.

  • 4.
    Jonsson, Peter A.
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    On building a supercompiler for GHC2008Conference paper (Other academic)
    Abstract [en]

    Supercompilation is a program transformation that removes intermediate structures and performs program specialization. We discuss problems and necessary steps for building a supercompiler for GHC.

  • 5.
    Jonsson, Peter A.
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Positive supercompilation for a higher order call-by-value language2009In: Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages: POPL'09 ; Savannah, Georgia, USA, January 21 - 23, 2009 / [ed] Benjamin C. Pierce, New York: ACM Digital Library, 2009, p. 277-288Conference paper (Refereed)
    Abstract [en]

    Previous deforestation and supercompilation algorithms may introduce accidental termination when applied to call-by-value programs. This hides looping bugs from the programmer, and changes the behavior of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higher-order call-by-value language and we prove that the algorithm both terminates and preserves termination properties. This algorithm utilizes strictness information for deciding whether to substitute or not and compares favorably with previous call-by-name transformations.

  • 6.
    Jonsson, Peter A.
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Positive supercompilation for a higher order call-by-value language: extended proofs2008Report (Other academic)
    Abstract [en]

    Previous deforestation and supercompilation algorithms may introduce accidental termination when applied to call-by-value programs. This hides looping bugs from the programmer, and changes the behavior of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higher-order call-by-value language and we prove that the algorithm both terminates and preserves termination properties. This algorithm utilizes strictness information for deciding whether to substitute or not and compares favorably with previous call-by-name transformations.

  • 7.
    Jonsson, Peter
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Positive supercompilation for a higher-order call-by-value language2010In: Logical Methods in Computer Science, ISSN 1860-5974, E-ISSN 1860-5974, Vol. 6, no 3, p. 1-39Article in journal (Refereed)
    Abstract [en]

    Previous deforestation and supercompilation algorithms may introduce accidental termination when applied to call-by-value programs. This hides looping bugs from the programmer, and changes the behavior of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higher-order call-by-value language and prove that the algorithm both terminates and preserves termination properties. This algorithm utilizes strictness information to decide whether to substitute or not and compares favorably with previous call-by-name transformations

  • 8.
    Jonsson, Peter
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Strengthening supercompilation for call-by-value languages2010In: Proceedings of the Second International Valentin Turchin Memorial Workshop on Metacomputation in Russia: Pereslavl-Zalessky, Russia, July 1–5, 2010 / [ed] A.P. Nemytykh, Pereslavl Zalessky: Ailamazyan University of Pereslavl , 2010, p. 64-81Conference paper (Refereed)
    Abstract [en]

    A termination preserving supercompiler for a call-by-value language sometimes fails to remove intermediate structures that a supercompiler for a call-by-name language would remove. This discrepancy in power stems from the fact that many function bodies are either non-linear in use of an important variable or often start with a pattern match on their first argument and are therefore not strict in all their arguments. As a consequence, intermediate structures are left in the output program, making it slower. We present a revised supercompilation algorithm for a call-by-value language that propagates let-bindings into case-branches and uses termination analysis to remove dead code. This allows the algorithm to remove all intermediate structures for common examples where previous algorithms for call-by-value languages had to leave the intermediate structures in place.

  • 9.
    Jonsson, Peter
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Taming code explosion in supercompilation2011In: Proceedings of the 20th ACM SIGPLAN workshop on Partial evaluation and program manipulation: PEMP 11, New York: ACM Digital Library, 2011, p. 33-42Conference paper (Refereed)
    Abstract [en]

    Supercompilation algorithms can perform great optimizations but sometimes suffer from the problem of code explosion. This results in huge binaries which might hurt the performance on a modern processor. We present a supercompilation algorithm that is fast enough to speculatively supercompile expressions and discard the result if it turned out bad. This allows us to supercompile large parts of the imaginary and spectral parts of nofib in a matter of seconds while keeping the binary size increase below 5%.

  • 10. Kero, Martin
    et al.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Timber as an RTOS for small embedded devices2005In: PREALWSN 2005: proceedings of the First Workshop on Real-World Wireless Sensor Network : Stockholm, Sweden, 20-21 June 2005, Kista: Swedish Institute of Computer Science , 2005Conference paper (Refereed)
    Abstract [en]

    Software development for small, real-time and resource constrained, embedded systems is becoming increasingly complex. To be able to guarantee robustness and reliability, the underlying infrastructure should not be based upon ad hoc solutions. In this paper we identify three key features of a minimalistic Real-Time Operating System (RTOS), and presents the run-time system of Timber, a reactive deadlinedriven programming language. We scrutinize the functionalities of the run-time system in the light of real-time requirements, and emphasize the importance of integrating an adequate notion of time, both semantically in the programming interface as well as part of the run-time system.

  • 11.
    Kero, Martin
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    A correct and useful incremental copying garbage collector2007In: Proceedings of the the 2007 International Symposium on Memory Management: Québec, Canada, October 21 - 22, 2007, New York: ACM Digital Library, 2007, p. 129-140Conference paper (Refereed)
    Abstract [en]

    Designing a garbage collector with real-time properties is a particularly difficult task, involving the construction of both an incremental run-time algorithm as well as methods enabling a priori reasoning about schedulability in two dimensions (time and memory usage in conjunction). In order to comply with such ambitious goals with any amount of formal rigor, a comprehensive understanding of the actual algorithm used is of course a fundamental requirement. In this paper we present a formal model of an incremental copying garbage collector, where each atomic increment is modeled as a transition between states of a heap process. Soundness of the algorithm is shown by proving that the garbage collecting heap process is weakly bisimilar to a non-collecting heap with infinite storage space. In addition, we show that our collector is both terminating and useful, in the sense that it actually recovers the unreachable parts of any given heap in a finite number of steps.

  • 12.
    Kero, Martin
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Pietrzak, Pawel
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Live heap space bounds for real-time systems2010In: Programming languages and systems: 8th Asian symposium, APLAS 2010, Shanghai, China, November28 - December 1 2010 : proceedings, Berlin: Encyclopedia of Global Archaeology/Springer Verlag, 2010, p. 287-303Conference paper (Refereed)
  • 13.
    Lindgren, Per
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Aittamaa, Simon
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Eriksson, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    TinyTimber, reactive objects in C for real-time embedded systems2008In: Proceedings, Design, Automation and Test in Europe: DATE '08 ; Munich, Germany, 10 - 14 March 2008 / [ed] Donatella Sciuto, New York: ACM Digital Library, 2008, p. 1382-1385Conference paper (Refereed)
    Abstract [en]

    Embedded systems are often operating under hard real-time constraints. Such systems are naturally described as time-bound reactions to external events, a point of view made manifest in the high-level programming and systems modeling language Timber. In this paper we demonstrate how the Timber semantics for parallel reactive objects translates to embedded real-time programming in C. This is accomplished through the use of a minimalistic Timber Run-Time system, TinyTimber (TT). The TT kernel ensures state integrity, and performs scheduling of events based on given time-bounds in compliance with the Timber semantics. In this way, we avoid the volatile task of explicitly coding parallelism in terms of processes/threads/semaphores/monitors, and side-step the delicate task to encode time-bounds into priorities. In this paper, the TT kernel design is presented and performance metrics are presented for a number of representative embedded platforms, ranging from small 8-bit to more potent 32-bit micro controllers. The resulting system runs on bare metal, completely free of references to external code (even C-lib) which provides a solid basis for further analysis. In comparison to a traditional thread based real-time operating system for embedded applications (FreeRTOS), TT has tighter timing performance and considerably lower code complexity. In conclusion, TinyTimber is a viable alternative for implementing embedded real-time applications in C today.

  • 14.
    Lindgren, Per
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Hyyppä, Kalevi
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Aittamaa, Simon
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Eriksson, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Comprehensive reactive real-time programming2008In: Hawaii International Conference on Education: 2008 Conference Proceedings, 2008, p. 1440-1448Conference paper (Refereed)
  • 15.
    Lindgren, Per
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Kero, Martin
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering.
    Eriksson, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Robust real-time applications in Timber2006In: 2006 IEEE International Conference on Electro/information Technology: East Lansing. MI, 7 - 10 May 2006, Piscataway, NJ: IEEE Communications Society, 2006, p. 191-196Conference paper (Refereed)
    Abstract [en]

    Embedded systems are often operating under hard real-time constraints, for example in automotive applications. For such systems, robustness and reliability are crucial, which calls for rigorous system design and methodologies for validation. In this paper we advocate a design methodology for robust, realtime systems, based on Timber; a pure reactive system model that allows for formal reasoning about various system properties. We outline how system specifications in Timber can be "compiled" into efficient standalone executables for general light-weight microcontroller platforms. Methods for resource analysis and implications to system dimensioning and validation are further discussed.

  • 16.
    Lindgren, Per
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Svensson, Linus
    Eriksson, Joakim
    Luleå tekniska universitet.
    Time for Timber2005Report (Other academic)
    Abstract [en]

    Embedded systems are often operating under hard real-time constraints, while at the same time being constrained by severe restrictions on power consumption. For such systems, robustness and reliability can be a question of life and death, which calls for rigorous system design and methodologies for validation. In this paper we advocate a design methodology for low-power, real-time systems, based on Timber; a pure reactive system model that allows for formal reasoning about various system properties. We outline how system specifications in Timber can be "compiled" into efficient standalone executables for general light- weight microcontroller based target platforms. Methods for resource analysis and implications to system dimensioning and validation are further discussed.

  • 17.
    Lisper, Björn
    et al.
    School of Innovation, Design and Engineering, Mälardalen University, Västerås.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    A simple and flexible timing constraint logic2012In: Leveraging applications of formal methods, verification and validation: technologies for mastering change : 5th International Symposium, ISoLA 2012, Heraklion, Crete, Greece, October 15-18, 2012 : proceedings / Part II / [ed] Tiziana Margaria ; Bernhard Steffen, Heidelberg: Encyclopedia of Global Archaeology/Springer Verlag, 2012, Vol. 2, p. 80-95Conference paper (Refereed)
    Abstract [en]

    Formats for describing timing behaviors range from fixed menus of standard patterns, to fully open-ended behavioral definitions; of which some may be supported by formal semantic underpinnings, while others are better characterized as primarily informal notations. Timing descriptions that allow flexible extension within a fully formalized framework constitute a particularly interesting area in this respect. We present a small logic for expressing timing constraints in such an open-ended fashion, sprung out of our work with timing constraint semantics in the TIMMO-2-USE project [15]. The result is a non-modal, first-order logic over reals and sets of reals, which references the constrained objects solely in terms of event occurrences. Both finite and infinite behaviors may be expressed, and a core feature of the logic is the ability to restrict any constraint to just the finite ranges when a certain system mode is active. Full syntactic and semantic definitions of our formula language are given, and as an indicator of its expressiveness, we show how to express all constraint forms currently defined by TIMMO-2-USE and AUTOSAR. A separate section deals with the support for mode-dependencies that have been proposed for both frameworks, and we demonstrate by an example how our generic mode-restriction mechanism formalizes the details of such an extension.

  • 18.
    Lisper, Björn
    et al.
    School of Innovation, Design and Engineering, Mälardalen University, Västerås.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Quinton, Sophie
    Institute of Computer Network and Engineering, TU Braunschweig.
    Timing constraints: theory meets practice2012In: Leveraging applications of formal methods, verification and validation: technologies for mastering change : 5th International Symposium, ISoLA 2012, Heraklion, Crete, Greece, October 15-18, 2012 : proceedings / Part II. / [ed] Tiziana Margaria ; Bernhard Steffen, Heidelberg: Encyclopedia of Global Archaeology/Springer Verlag, 2012, Vol. 2, p. 78-79Conference paper (Refereed)
    Abstract [en]

    Many embedded systems must satisfy timing requirements, which describe how these systems should behave with respect to timing. Such requirements must be dealt with throughout the system development process: from their initial specification, expressed at an abstract level, through the increasingly concrete layers, to the final implementation level. There is a growing awareness that this process needs support from languages, tools, and methodologies

  • 19. Nordlander, Johan
    Lazy computations in an object oriented language for reactive programming1995In: SIPL '95, Second ACM SIGPLAN Workshop on State In Programming Languages, 1995Conference paper (Refereed)
  • 20.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Polymorphic subtyping in O'Haskell2002In: Science of Computer Programming, ISSN 0167-6423, E-ISSN 1872-7964, Vol. 43, no 2-3, p. 93-127Article in journal (Refereed)
    Abstract [en]

    O'Haskell is a programming language derived from Haskell by the addition of concurrent reactive objects and subtyping. Because Haskell already encompasses an advanced type system with polymorphism and overloading, the type system of O'Haskell is much richer than what is the norm in almost any widespread object-oriented or functional language. Yet, there is strong evidence that O'Haskell is not a complex language to use, and that both Java and Haskell programmers can easily find their way with its polymorphic subtyping system. This paper describes the type system of O'Haskell both formally and from a programmer's point of view; the latter task is accomplished with the aid of an illustrative, real-world programming example: a strongly typed interface to the graphical toolkit Tk.

  • 21. Nordlander, Johan
    Pragmatic subtyping in polymorphic languages1999In: Proceedings of the third ACM SIGPLAN International Conference on Functional Programming: ICFP '98, IEEE Communications Society, 1999, p. 216-227Conference paper (Refereed)
    Abstract [en]

    We present a subtyping extension to the Hindley/Milner type system that is based on name inequivalence. This approach allows the subtype relation to be de ned by incremental construction of polymorphic records and datatypes, in a way that subsumes the basic type systems of both languages like ML and Java. As the main contribution of the paper, we describe a partial type inference algorithm for the extended system which favours succinctness over generality, in the sense that it never infers types with subtype constraints. The algorithm is based on an effcient approximating constraint solver, and is able to type a wide range of programs that utilize subtyping and polymorphism in a non-trivial way. Since constrained types are not inferred, the algorithm cannot be complete; however, we provide a completeness result w. r. t. the Hindley/Milner type system as a form of characterizing lower bound.

  • 22.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Programming with the TinyTimber kernel2007Report (Other academic)
    Abstract [en]

    This document describes the C programming interface to TinyTimber, a very small and lightweight run-time kernel for event-driven embedded systems.

  • 23. Nordlander, Johan
    Reactive objects and functional programming1999Doctoral thesis, comprehensive summary (Other academic)
    Abstract [en]

    The construction of robust distributed and interactive software is still a challenging task, despite the recent popularity-increase for languages that take advanced programming concepts into the mainstream. Several problematic areas can be identified: most languages require the reactivity of a system to be manually upheld by careful avoidance of blocking operations; mathematical values often need to be encoded in terms of stateful objects or vice versa; concurrency is particularly tricky in conjunction with encapsulated software components; and static type safety is often compromised because of the lack of simultaneous support for both subtyping and polymorphism.This thesis presents a programming language, O'Haskell, that has been consciously designed with these considerations in mind. O'Haskell is de ned by conservatively extending the purely functional language Haskell with the following features:- A central structuring mechanism based on reactive objects, which unify the notions of objects and concurrent processes. Reactive objects are asynchronous, state-encapsulating servers whose purpose is to react to input messages; they cannot actively block execution or selectively filter their sources of input.- A monadic layer of object-based computational effects, which clearly separates stateful objects from stateless values. Apart from higher-order functions and recursive data structures, the latter notion also includes first-class commands, object templates, and methods.- A safe, polymorphic type system with declared record and datatype subtyping, supported by a powerful partial type inference algorithm.It is claimed that these features make O'Haskell especially well-adapted for the task of modern software construction. The thesis presents O'Haskell from both a practical and a theoretical perspective. The practical contributions are a full implementation of the language, a number of non-trivial programming examples that illustrate the merits of reactive objects in a realistic context, and several reusable programming methods for such applications as graphical user interfaces, embedded controllers, and network protocols. The theoretical results serve to substantiate the informal claim made regarding usability, and include a provably sound polymorphic subtyping system, soundness and partial completeness for the inference algorithm, a formal dynamic semantics, and a result that characterizes the conservative extension of a purely functional language with state and concurrency.

  • 24. Nordlander, Johan
    et al.
    Carlsson, Magnus
    Reactive objects in a functional language: an escape from the Evil I1997In: Proceedings of the 1997 ACM SIGPLAN International Conference on Functional Programming: Amsterdam, The Netherlands, June 9 - 11, 1997, New York: ACM Digital Library, 1997Conference paper (Refereed)
    Abstract [en]

    We present an extension to Haskell which supports reactive, concurrent programming with objects, sans the problematic blocking input. We give a semantics together with a number of programming examples, and show an implementation based on a preprocessor and a library implementing seven monadic constants.

  • 25.
    Nordlander, Johan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Carlsson, Magnus
    Galois Inc., Portland, OR.
    Gill, Andy J.
    University of Kansas, Lawrence, KS.
    Unrestricted pure call-by-value recursion2008In: ML'08: proceedings of the 2008 ACM SIGPLAN Workshop on ML ; Victoria, British Columbia, Canada, September 21 2008 ; co-located with ICFP '08, New York: ACM Digital Library, 2008, p. 23-34Conference paper (Refereed)
    Abstract [en]

    Call-by-value languages commonly restrict recursive definitions by only allowing functions and syntactically explicit values in the right-hand sides. As a consequence, some very appealing programming patterns that work well in lazy functional languages are hard to apply in a call-by-value setting, even though they might not be using laziness for any other purpose than to enable the desired form of recursion.In this paper we present an operational semantics as well as a straightforward implementation technique for unrestricted recursion under pure call-by-value. On that basis we are able to demonstrate that highly recursive programming idioms such as combinator-based parsing are indeed compatible with call-by-value evaluation.

  • 26.
    Nordlander, Johan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Carlsson, Magnus
    Carmen Systems.
    Jones, Mark P.
    Oregon Health & Science University.
    Jonsson, Jan
    Chalmers University of Technology.
    Programming with time-constrained reactions2005Report (Other academic)
    Abstract [en]

    In this paper we argue that a programming language for real-time systems should support the declaration of time-constraints, and that those constraints should attach to a welldeveloped notion of reactions. To make our claims more precise, we introduce Timber, which is a concurrent programming language based on a model of non-blocking, reactive objects. Timber supports both upper and lower time constraints on a reaction, where upper constraints correspond to classical deadlines, and lower constraints constitute the systematic capturing of well-defined points in the future as events in their own right. A series of programming examples illustrates how these mechanisms can be used to express simple solutions to common problems in practical real-time programming, and the relation between Timber and deadline-based scheduling theory is explored.

  • 27.
    Nordlander, Johan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Johansson, Rolf
    Mentor Graphics.
    Pathan, Risat Mahmud
    Chalmers University of Technology.
    Unambiguous semantics in automotive timing modeling2010In: Proceedings of the 1st Workshop on Critical Automotive applications : Robustness & Safety : CARS 10: Valencia, Spain, ACM Digital Library, 2010, p. 39-42Conference paper (Refereed)
    Abstract [en]

    This paper shows how the ITEA2 research project TIMMO has chosen to model timing constraints for delays and for synchronization in an unambiguous way. The shown timing model is valid even in systems where jitter and over- and under-sampling appears. These timing constraints can be used to model timing by augmenting both the AUTOSAR and EAST-ADL2 languages. The unambiguous semantics enables the use of timing models for building safety cases and for precise communication between different parties involved in safety-critical automotive applications.

  • 28.
    Nordlander, Johan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Jones, Mark P.
    Carlsson, Magnus
    Kieburtz, Richard B.
    Black, Andrew P.
    Reactive objects2002In: Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing, Piscataway, NJ: IEEE Communications Society, 2002, p. 155-158Conference paper (Refereed)
    Abstract [en]

    Object-oriented, concurrent, and event-based programming models provide a natural framework in which to express the behavior of distributed and embedded software systems. However, contemporary programming languages still base their I/O primitives on a model in which the environment is assumed to be centrally controlled and synchronous, and interactions with the environment carried out through blocking subroutine calls. The gap between this view and the natural asynchrony of the real world has made event-based programming a complex and error-prone activity, despite recent focus on event-based frameworks and middleware. In this paper we present a consistent model of event-based concurrency, centered around the notion of reactive objects. This model relieves the object-oriented paradigm from the idea of transparent blocking, and naturally enforces reactivity and state consistency. We illustrate our point by a program example that offers substantial improvements in size and simplicity over a corresponding Java-based solution.

  • 29.
    van Deventer, Jan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Kruglyak, Andrey
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Delsing, Jerker
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Platform independent system integration2011In: SAE 2011 World Congress & Exhibition Technical Papers: April 12 - 14, 2011, Detroit, Michigan, USA ; [papers], Warrendale, Pa: Society of Automotive Engineers, Incorporated , 2011Conference paper (Refereed)
    Abstract [en]

    This paper presents and demonstrates a paradigm to implement automotive systems based on their specifications in a manner that is platform independent. The advantage is to have the same software used in simulation as on different types of micro-controller in a vehicle as well as to ease the integration of different systems. The paradigm is to model the system’s components as reactive objects and to use the Timber kernel to schedule their (re)actions. The demonstration is done by developing an anti-lock braking system within the simulation software CarSim and Simulink, which is then evaluated on a braking maneuver over a surface with different coefficient of adhesion from side to side (split mu).

  • 30. Wallin, Stefan
    et al.
    Leijon, Viktor
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Bystedt, Niklas
    Yalt.
    The semantics of alarm definitions: enabling systematic reasoning about alarms2012In: International Journal of Network Management, ISSN 1055-7148, E-ISSN 1099-1190, Vol. 22, no 3, p. 181-198Article in journal (Refereed)
    Abstract [en]

    The development and integration of an alarm interface between network elements and a network management system is a costly process, largely because of the informal way in which alarm interfaces are expressed and communicated. Low-quality alarm documentation and confusion around fundamental concepts like alarm states and alarm types are typical consequences of current practices. If alarm interfaces were expressed in a more formal manner, costs could be reduced and more advanced analysis and automation would be enabled. We present a novel approach to alarm interfaces by providing a formal alarm model together with a domain-specific language that allows us to specify both the alarm models and the constraints placed on the alarm models in a consistent manner. This means that we can verify the consistency of an alarm interface and automatically generate artifacts such as alarm correlation rules or alarm documentation based only on the model

  • 31.
    Wallin, Stefan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Nordlander, Johan
    Leijon, Viktor
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering.
    Semantic Alarms2014In: 3rd ETSI Future Networks Workshop, 9-11 april 2013, Sophia Antipolis, France / [ed] Alex Galis; Gaby Lenhart, 2014, p. 145-153Conference paper (Other (popular science, discussion, etc.))
    Abstract [en]

    Functions Virtualisation (NFV) and Software Driven Networks (SDN) aggregate resources across multiple domains. This puts requirements on understanding the overall alarm status across these domains and dependencies between them. Current practice of low-quality alarm documentation and confusion around fundamental concepts like alarm states, alarm-types and the underlying protocols like syslog and SNMP traps makes it hard to create one unified alarm interface as part of the SDN API.If alarm interfaces for the various components were expressed in a more formal manner including dependencies and propagation between the alarms the NFV/SDN interface could automatically present an integrated alarm API as well as a synthesized alarm state across the virtualized functions.We present a novel approach to alarm interfaces by providing a formal alarm model together with a domain-specific language that allows us to specify both the alarm models and the constraints placed on the alarm models in a consistent manner. This means that we can verify the consistency of an alarm interfaces and automatically generate interfaces, multi-domain correlation and aggregated states.

  • 32.
    Wallin, Stefan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Åhlund, Christer
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Rethinking network management: models, data-mining and self-learning2012In: Proceedings of the 2012 IEEE Network Operations and Management Symposium: Maui, HI 16- 20 April 2012, Piscataway, NJ: IEEE Communications Society, 2012, p. 880-886Conference paper (Refereed)
    Abstract [en]

    Network Service Providers are struggling to re- duce cost and still improve customer satisfaction. We have looked at three underlying challenges to achieve these goals; an overwhelming flow of low-quality alarms, understanding the structure and quality of the delivered services, and automation of service configuration. This thesis proposes solutions in these areas based on domain-specific languages, data-mining and self- learning. Most of the solutions have been validated based on data from a large service provider.We look at how domain-models can be used to capture explicit knowledge for alarms and services. In addition, we apply data- mining and self-learning techniques to capture tacit knowledge. The validation shows that models improve the quality of alarm and service models, and automatically render functions like root cause correlation, service and SLA status, as well as service configuration automation.The data-mining and self-learning solutions show that we can learn from available decisions made by experts and automatically assign alarm priorities.

  • 33.
    Wiklander, Jimmie
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Eliasson, Jens
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Kruglyak, Andrey
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Enabling component-based design for embedded real-time software2009In: Journal of Computers, ISSN 1796-203X, E-ISSN 1796-203X, Vol. 4, no 12, p. 1309-1321Article in journal (Refereed)
    Abstract [en]

    The increasing complexity of embedded software calls for a new, more efficient design approach. A natural choice is to use well-established component-based design; however, its adoption to design of embedded software has been slow and riddled with difficulties. It can be argued that these problems are due to the following peculiarities of embedded systems. Firstly, the tight integration between hardware and software, typical for embedded systems, makes it virtually impossible to model and implement software separately from hardware. Secondly, it is difficult to express timing requirements, an intrinsic part of functionality of many embedded systems, in dataflow abstractions traditionally used in component-based design. We propose to overcome these difficulties by introducing a uniform, consistent modeling of both hardware and software and by integrating timing requirements into the model. We present a modeling framework based on the notions of reactive objects and time-constrained reactions, which enables component-based design of embedded real-time systems. Within this framework, functionality of both hardware and software components is defined in terms of reactions to discrete external events, and timing requirements are specified for each reaction relative to the event that triggered it. We also present a detailed software design methodology for embedded real-time systems based on our modeling framework.

  • 34.
    Wiklander, Jimmie
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Kruglyak, Andrey
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Personal alarm device: a case study in component-based design of embedded real-time software2011Conference paper (Other academic)
    Abstract [en]

    Designing software for embedded systems is complicated by such factors as the tight integration between software and hardware, scarceness of available resources, and hard real-time requirements. In our earlier work we proposed a component-based approach based on modeling both hardware and software using reactive objects and time-constrained reactions, which should allow us to overcome these difficulties. We also presented a software design methodology for embedded real-time systems.Here we describe a system developed using this methodology and discuss its advantages. The system is a personal alarm device that should be worn at the waist of a person and that should detect his or her fall and send an alarm signal. The implementation of the system was verified using a Simulink-based simulator. The simulation demonstrated that, even though calculation of acceleration was simplified to allow for an efficient execution on a resource-constrained platform, fall detection remained satisfactory.The case study demonstrates the advantages of the proposed software design methodology, including the fact that functional and timing properties of a system model can be preserved during implementation process by means of a seamless transition between a model and an implementation.

1 - 34 of 34
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf