Welcome to the Visi Language blog. Here are the most recent blog posts:
  • First Xcode Screencast

    February 8, 2013

    First Xcode Screencast

    I've put together a screencast of integrating a Visi model into an iPad app using Xcode: http://tunaforcats.com/Visiipaddemo.mov.

    The workflow is as follows:

    • Create an iPad app
    • Copy the visi.jar compiler into the project
    • Create your Visi model
    • Compile the Visi model
    • Subclass your controller from the generated Objective-C code
    • Wire up your app
    • Update your model
    • Re-wire your app

    In Visi, all inputs are done via "Sources" and all outputs are "Sinks".

    Each time a source changes (signals) all the dependent sinks are recomputed and signaled.


  • Moving Forward

    January 10, 2013

    Moving Forward

    The Scala port of Visi now has more features than the Haskell version.

    The Scala version of Visi compiles to JavaScript and within JavaScript, it supports lazy evaluations via Thunks.

    The dependency graph works correctly such that Visi can determine all the sinks (outputs) what change based on a source changing.

    The JavaScript runtime correctly does minimal recomputation such that only the sinks impacted by a set of sources changing will be recalculated.

    Also, if there are any parameterless functions that depend on a source, they will be reset before the sinks are recomputed.

    Most importantly, recursive parameterless functions work correctly. For example:


  • Scala Port Status

    December 27, 2012

    Quick Update on the Visi Scala Port

    The basic Visi parser is ported from Haskell to Scala.

    I used the Parboiled parser because it has much better performance and location capturing capabilities than does Scala's built in parser combinators.

    The basic type checker is working and most of the test cases from Haskell are passing. I haven't ported all the tests, but the ones I have ported are working.

    In addition to having a running typer, Visi also calculates the dependency graph for each node in the typed lambda calculus. This will come in handy.


  • New Visi Development Direction

    December 4, 2012

    New Visi Development Direction

    A lot of things "came together" on Sunday. I judged at AngelHack, I met with the founder and the technology guy from a promising startup (not an AngelHack participant), and I had breakfast with Alexis Richardson in which we started chatting about Visi.

    Alexis is an excellent combination of technical and business and he kept asking me hard questions about Visi, where Visi models could execute, development environments, etc.

    After the meeting, I had an hour-long, very rainy drive from San Francisco to San Jose.


  • Emerging Languages Presentation

    December 3, 2012

    Visi Presentation at the Emerging Languages Camp

    Alex Payne invited me to present at the 2012 Emerging Languages Camp in Saint Louis this year.

    The conference was jam packed with some of the most amazing languages and language developers.

    Here's a video of my presentation. It's a pretty good representation of the goals and motivations of the Visi language as well as the current state of the code.

    Enjoy.


  • Literate Visi

    January 13, 2012

    In master, Visi is now a literate programming language.

    Visi models (models are descriptions of business logic as well as sources of input and sinks to output) are valid GitHub flavored Markdown documents.  Any code blocks (delimited by a line starting with ```) are considered Visi code and are parsed according to the Visi grammar.  Anything outside the ``` blocks are regular Markdown.

    Why is Literate Programming important?


  • Visi the Language vs. Visi.Pro the platform

    January 8, 2012

    I want to draw a distinction between the Visi language and the Visi.Pro platform.


  • Program lifecycle phases

    January 5, 2012

    We developer types have a couple of pre-set modes or notions about code life-cycles.

    If you come from the "dynamic" language school, the cycle looks something like:
    1. Sometimes use a REPL. Type lines of code into something and get answers.  You know, irb.
    2. Change the code and re-run it/reload the web page.  Does it work?  Cycle back to 1.  Cycle time: 30 seconds.
    3. Run some tests.  Okay, they pass.  Or maybe you ignore this phase.
    4. Commit the code to a repository.
    5. Maybe a Continuous Integration system does its thing.
    6. Publish the code to your user-base.
    If you come from C/C++/Java-land, life looks something like:

  • What is Visi?

    January 5, 2012

    Visi is a new language... a "what if Haskell and Excel" had a love-child kind of language.  Visi is pure, lazy, just like Excel, yet Visi is statically typed, like Haskell.  Visi's syntax is beautiful, in a Haskell/Python sort of way, yet inviting to spreadsheet users.  Visi is targeted as a HyperCard-like language for the iPad and the cloud, but with a firm grounding in computer science that has evolved since the mid-80s.  Visi is built in Haskell and takes advantage of the GHC platform.  David Pollak, the inventor of the real-time spreadsheet, founded the Visi project which can be found at http://visi.io
  • Wow... Visi works

    December 16, 2011

    Well, it's been a month since I announced the whole Visi thing.  When I announces, I had a barely functional type checker and inferencer and a barely functional expression evaluator.

    That's all changed in the last month.  As I've gotten my Haskell Foo on and gone with an existing implementation of Hindley-Milner type checking rather than trying to write my own from first principals, I've made a ton of progress with the Visi language.

    For example, Visi can implement Factorial:

    fact n = if n == 0 then 1 else n * fact n - 1
    res = fact 10 //  testResults [("res", DoubleValue 3628800)] . checkResults)


  • Mmm... sweet tasty state monads

    December 12, 2011

    One of the really challenging things about Haskell is the lack of state... or more specifically, the lack of global state.

    In Scala there are a ton of places you can put state (stuff that's mutated across method invocations.)  You can use globals, thread-local variables (something that Lift makes heavy use of), and instance variables.  Here are some examples:

    Global:

    object MyState {
      private var cnt = 0

      def inc = synchronized {cnt += 1}
      def dec = synchronized {cnt -= 1}
      def getCnt = synchronized {cnt}
    }

    Instance variables are pretty much the same, except you have to pass the instance around:


  • It was 20 years ago today...

    November 17, 2011

    It was 20 years ago today that I embarked on an epic computer journey that defined my life as a coder and a business-person.  On November 17th, 1991, I laid down the first lines of code for the Mesa spreadsheet.

     

    Mesa was a spreadsheet for NextStep and continues (without my help) to be a spreadsheet for OS X (which is the updated version of NextStep.) At the time I started coding Mesa, the spreadsheet category on NextStep was surprisingly crowded with an entry from Lotus, the amazing, but non-traditional Improv, and WingZ from Informix.  Additionally, a venture funded company was working on traditional, native NextStep spreadsheet called PowerStep.