( en | de | ru )

 

  2. tag
  3. pl

bookmarks  214

  •  

    K4 by EXAMPLE K4 is product of Kx Inc. http://kx.com 2006.02.23. 22:15 Attila Vrabecz (VrAbi) http://vrabi.web.elte.hu/k based on J by EXAMPLE by 06/11/2005 (C) Oleg Kobchenko http://olegykj.sourceforge.net
    13 years ago by @draganigajic
     
      codeexamplekpl
      (0)
      copydelete
       
       
    •  

      Advantages of Soft Typing This is a continuation of this discussion. The main points for soft typing are as follows. * Compile time type checks. Soft typing can catch the same amount of provable errors at compile time as static typing. * Automatic downcasts. Downcasts are done automatically assuming the program passes type checking. The main argument for explicit casts is that it provides the programmer with more information, but this is a misnomer. One does not have to write down information for it to be shown to him, so long as said information is inferrable. Note: whether or not you believe OCaml doesn't have casting is irrelevant, simply assume that, when I refer to casting, I also mean situations in which it's emulated. * Unimposing. Unless a piece of code is provably incorrect at compile time, the compiler can insert runtime checks.
      13 years ago by @draganigajic
       
        discussionltupltyping
        (0)
        copydelete
         
         
      •  

        Overview Chameleon is a Haskell style language and supports * Type classes * User-programmable CHRs * Extended algebraic data types * Lexically scoped type annotations
        13 years ago by @draganigajic
         
          cshaskellplresearchwiki
          (0)
          copydelete
           
           
        •  

          Maude is a high-performance reflective language and system supporting both equational and rewriting logic specification influenced by the OBJ3 language, which can be regarded as an equational logic sublanguage. Besides supporting equational specification and programming, Maude also supports rewriting logic computation. Rewriting logic is a logic of concurrent change that can naturally deal with state. It has good properties as a general semantic framework for giving executable semantics to a wide range of languages and models of concurrency. In particular, it supports very well concurrent object-oriented computation. The same reasons making rewriting logic a good semantic framework make it also a good logical framework, that is, a metalogic Maude supports in a systematic and efficient way logical reflection; supports an extensible algebra of module composition operations, and allows many advanced metaprogramming and metalanguage apps
          13 years ago by @draganigajic
           
            csobj3plresearch
            (0)
            copydelete
             
             
          •  

            "OBJ" refers to the language family, with OBJ3, CafeOBJ, BOBJ. The OBJ are algebraic prog and spec languages, based on order sorted equational logic, possibly enriched with other logics (such as rewriting logic, hidden equational logic, or first order logic), with module system of parameterized programming They are logical languages, in the sense that their programs are sets of sentences in some logical system, and their operational semantics is given by deduction in that logical system. All recent OBJ languages use order sorted algebra, with a rigorous basis for user definable sub-types, multiple inheritance, overloading, multiple representations, coercions, etc. also user definable mixfix syntax, execution strategies, and memoization. All recent OBJ languages provide parameterized modules, module instantiation, views, module expressions, etc., to support very flexible program structuring and reuse The module systems of Ada, ML, C++ have all been influenced by the OBJ
            13 years ago by @draganigajic
             
              cslogicobj3plresearch
              (0)
              copydelete
               
               
            •  

              NEPLS, the New England Programming Languages and Systems Symposium Series, is a regional venue to discuss current research in programming languages and systems. If you are unfamiliar with such events and would like an idea of what to expect, look at the agendas from our previous meetings (at the bottom of this page) as points of reference.
              13 years ago by @draganigajic
               
                conferencecsplresearch
                (0)
                copydelete
                 
                 
              •  

                Stratego/XT is a language and toolset for constructing stand-alone program transformation systems. It combines the Stratego transformation language with the XT toolset of transformation components, providing a framework for constructing stand-alone program transformation systems. The Stratego language is based around a programming paradigm called strategic term rewriting. It provides rewrite rules for expressing basic transformation steps. The application of these rules can be controlled using strategies, a form of subroutines. The XT toolset provides reusable transformation components and declarative languages for deriving new components. Program transformations often operate by modifying the (AST). In Stratego it is also possible to specify transformations using concrete syntax. This allows programmers to express a transformation using the familiar (and often more concise) syntax of the object programming language, while it internally still operates on the AST.
                13 years ago by @draganigajic
                 
                  csmetaprogrammingplstrategotransformationwikipedia
                  (0)
                  copydelete
                   
                   
                •  

                  As you probably can tell Maude sets out to solve a different set of problems than ordinary imperative languages. It is a formal reasoning tool, which can help us verify that things are "as they should", and show us why they are not if this is the case. Maude lets us define formally what we mean by some concept in a very abstract manner, but we can describe what is thought to be the equal concerning our theory (equations) and what state changes it can go through (rewrite rules). This is useful to validate security protocols and critical code. The Maude system has proved flaws in cryptography protocols by just specifying what the system can do , and by looking for unwanted situations the protocol can be showed to contain bugs, not programming bugs but situations happen that are hard to predict just by walking down the "happy path" as most developers do. We can use Maude's built-in search to look for unwanted states, or it can be used to show that no such states can be reached.
                  13 years ago by @draganigajic
                   
                    logicmaudemetaprogrammingobj3plresearchrewritingwikipedia
                    (0)
                    copydelete
                     
                     
                  •  

                    Chameleon (the language) is a Haskell style language to experiment with advanced type extensions such as type classes and generalized algebraic data types. The user can program her own type extensions via Constraint Handling Rules (CHRs). Chameleon (the system) is also a compiler framework. Chameleon has been applied in a number of project such as type error reporting, programming language program verification etc. In the XHaskell implementation we heavily rely on the compiler infrastructure provided by Chameleon. Language Features * LanguageOverview * HowtoinstallandrunChameleon The Compiler * CompilerOverview * ChameleonGecko * StandaloneSolver Applications *TypeErrorDiagnosis *ProgramVerification MartinSulzman
                    13 years ago by @draganigajic
                     
                      compilerfpgadthaskellomegapltypes
                      (0)
                      copydelete
                       
                       
                    •  

                      I’ve been working on file handling and concurrency recently, using the type system to manage state to prevent unauthorised access to resources and to ensure locks are managed correctly, even looking at how types can help prevent deadlock. I’ve been doing this in Ivor, but I think now is the time to give it a go in a real language. To this end… …I’ve spent the last few weeks hacking on a fledgling dependently typed language called Idris. It has full dependent types, pattern matching, and some basic IO with Haskell style do notation. I’ve tried a few simple examples, including the traditional well-typed interpreter. Types need to be given for pattern matching functions, but can often be omitted for constants - full type inference is of course impossible with full dependent types.
                      13 years ago by @draganigajic
                       
                        blogpostdependent-typesfppl
                        (0)
                        copydelete
                         
                         

                      publications  33