• b

    Ben Kirwin

    8 months ago
    👋 hi! i'm ben - new here, though i've been enjoying the podcast for a little while now current special interest: i've been experimenting with homebrew software for the remarkable tablet (for those unfamiliar: it's an e-ink tablet, with low-enough latency that it's also nice to write on) and i'm curious what a good programming environment for that sort of paperlike interface would look like
    b
    i
    +4
    13 replies
    Copy to Clipboard
  • Vitaly Malyshev

    Vitaly Malyshev

    8 months ago
    Hi everyone! 👋 My name is Vitaly Malyshev, I am a co-founder and CEO of Kelp. I have been working with our wonderful team for over 3 years now on what we see as a next-gen visual development platform. Still in beta, but we welcome anyone to try it out. I live in NJ with my wife and two kids. I’m passionate in data, design and robots. Here to learn and help with anything I can.
    Vitaly Malyshev
    i
    2 replies
    Copy to Clipboard
  • Yueh Han Huang

    Yueh Han Huang

    8 months ago
    Hi! I’m a Yueh Han, a CS student at Minerva, based in Taipei/Berlin/SF. I discover the community through the Alan Kay blog post, and felt nice to be here! Looking forward to discover ideas and gems shared by everyone. I enjoy recording my reading on Curius, feel free to take a look! https://curius.app/yueh%20han-huang
    Yueh Han Huang
    1 replies
    Copy to Clipboard
  • James Haliburton

    James Haliburton

    7 months ago
    Hi all - My name is James Haliburton. Co-founder and CEO at Noodl (www.noodl.net). Visual, flow-based programming environment - challenging the need for code in complex web app and prototype development. I'm hoping to share work and demos on here from time to time, if you're up for it.
    James Haliburton
    i
    3 replies
    Copy to Clipboard
  • Gilbert Wat

    Gilbert Wat

    7 months ago
    Hey everyone! 👋 I am Gilbert and I am working in a EdTech startup based in Hong Kong, delivering quality and personalized software development and data science training to adult and kids alike. Looking forward to jam and be part of the future of coding 😉 .
    Gilbert Wat
    1 replies
    Copy to Clipboard
  • Noah Tell

    Noah Tell

    7 months ago
    Hi everyone! Just wanted to share my story and idea and maybe find someone that's been on similar thoughts or that is interested. Here comes a wall of text. Feel free to ask questions! I've been thinking of a new form of computer communication for years now. My goals have been among others implicit abstractions similar to interfaces which include reusability, simple hardware and network integration, automatic data structure handling and implicit parallelization. I've been reading theoretical computer science on master level and was first very fascinated by LISP and Scheme, but after working in Business Intelligence and with analysis cubes and DAX for 2 years, my thoughts have been inspired by the idea of dimensions and the power that abstraction provide. However, I think DAX is very limited. What I've arrived at is a concept I call dimensional programming. By nature it is declarative and entirely based on setting dependencies between dimensions. My approach has similarities to algebra in how equality work in contrast to imperative programming. Although, it come with some distinct differences for handling dimension "types" effectively. The primary idea is to model a computer as a space of input and output dimensions. Input dimensions being keyboard, mouse, camera, microphone, files etc. Output dimensions: monitor, speaker, files etc. Depending on the source or sink several dimensions are integrated, e.g. a monitor require xy-axis for pixels bound to rgb-color. A program effectively becomes a point that moves through this hyper space, propelled by time (which I believe is not a new idea). The programming process consists of creating dependencies between input dimension and new intermediate dimensions until they reach output dimensions. The time dimension is key for most functionality and can be used to create virtual imperative programming when required. The programming engine is tasked with creating a program that guarantee the dependency between input and output dimensions for whenever the output dimension must show. This removes the programmers responsibility of saying when things should operate. Function calls and events are chosen, handled and optimized by the compiler. It is possible to create dependent spaces of several dimensions to create basically modules. We then connect other dimensions to the ends (dimensions) to the module and then adapt the behavior. One of the charm with such modules are that they can be complex but we only need to compile and run the parts that has dependencies between input and output dimensions. Types are not a thing. Instead points are mapped between dimensions or based on the shape of a dimension, such as its cardinality which can be used accumulate things over time. Arithmetic is handled by dependencies from the number dimension onto itself based on operators. The fact that dimensions don't really use types seem to create this abstraction criteria I was looking for. Compilation wise, input and output dimensions are implemented through an interface to provide deltas or full changes for the compiler to optimize the program with. The interface should be sophisticated enough to map to REST APIs or other programming languages or data sources. There are plenty of theoretical difficulties with foremost avoiding circular dependencies. This has been a big trouble, but seems to be solvable null points of each dimension where no dependency exist as well as only considering direct chains of dependencies. There are some very cool implications with these thoughts of dimensions. A number is just a dimension. A list of numbers is just a number dimension that depends on another discrete dimension. If statements are just points in spaces of one or more dimension causing other dependencies. Logical operations naturally convert in to something more like set theory. The current thought of syntax is very compact requiring few to none keywords. It mostly just looks like common list syntax and rely on pattern matching. I'm in a fairly late stage theoretically and are aiming at creating a proof of concept soon, probably binding the console input field dimension accumulated over time to the output over the time dimension. But I'm also looking at using Vulcan to implement a monitor output dimension. There seem to be many other interesting potentials for the future: -We can have a computer dimension and program dimensions which allow very straight forward syntax for having programs communicating with each other across the internet.- We could get implicit inversion of dependency mappings, effectively making it possible to run programs or dependencies backwards (which could lead to program branching, but there is theory for that too). - I've also considered how to visualize such a program. Any pair of dimensions can for example be plotted on a regular 2D graph. In a sense the entire program is defined before it runs, although we can't know certain input dimension states ahead of time. It causes potentials for visual exploration and debugging. Overall there is a lot of work to do and I will try to get the POC out to show a more concrete example, but until then I'm happy to talk about it!
    Noah Tell
    Meng Weng Wong
    2 replies
    Copy to Clipboard
  • Andy Jakubowski

    Andy Jakubowski

    7 months ago
    Hi everyone 👋 I’ve been reading posts in this community for a while now, and I figure it may be time to finally introduce myself. @Florian Schulz and @hvrosen separately told me about it some time last year. They’re both awesome people working on impressive projects, so I knew I had to come here 🙂 My background is a mix of business, programming, and design. My business school experience was pretty disappointing, so I started teaching myself programming and selling iPhone apps on the side shortly after Apple had created the App Store. The apps were super simple and had moderate success. Following Apple’s guidelines and reading articles by other indie developers made me realize the importance of good design. That’s when I encountered Bret Victor’s essays for the first time, and they had a huge impact on me. I really enjoyed creating new products, and ended up moving from Poznań, Poland to Berlin, Germany, and working as a product designer for about ten years. I enjoyed product design, but felt limited in the sense that I could envision certain ideas, but was incapable of implementing them myself. And pushing the envelope was not always a priority at my clients’ companies (understandably so). So I decided to take some time off and invest in learning programming for real. After about three years of first learning programming fundamentals and then catching up with modern tools, I’m now building a paid learning resource and environment for people who want to learn CSS Flexbox layout. I’m following some of the guidelines outlined in Bret Victor’s Learnable Programming essay, like removing hidden state and letting you explore how a layout is constructed over time. My other inspirations are books like Uncommon Sense Teaching (Oakley, Rogowsky, Sejnowski) for creating a curriculum and tools that make learning accessible to everyone, and Understanding Comics by Scott McCloud for employing visual communication and stories to better explain concepts. I effectively had to reverse engineer how a browser engine calculates this type of layout so that I could show all the intermediate states to the user. This has been pretty challenging, but I think it could really make learning much easier compared to what it is today. I’m hoping to launch it some time in 2022. I’m a little scared talking about this project at this stage, because it doesn’t completely implement Bret Victor’s vision yet. But after a long time off work, I feel like I might need to settle for something less than perfect so I can start supporting myself with this independent business. In terms of other projects, last year I was looking for better ways of modeling interfaces and got into statecharts. I really loved the original statecharts paper from David Harel. To get some practice, I built a replica of the wristwatch the author used for all the examples. The demo can be found at https://andyjakubowski.github.io/statechart-watch/, and the source code at https://github.com/andyjakubowski/statechart-watch. This ended up pretty long 😬 Anyway, I have huge respect for what you’re all working on in this community, and I’m looking forward to becoming a little more active here!
    Andy Jakubowski
    j
    +5
    12 replies
    Copy to Clipboard
  • j

    Jeffrey M Barber

    6 months ago
    Hello! My name is Jeff, and a friend of mine clued me into this forum. A bit about me. I’m a semi-retired former principal engineer and my new life goal is to connect with why I got into this field in the first place: games. My career was forged in distributed systems at Amazon S3 which prepared me to the architect of Facebook’s real-time infrastructure which manifested in a SOSP 21 paper: https://dl.acm.org/doi/10.1145/3477132.3483572 I've been working on a new programming language for a while called Adama, and I'm turning it into a data platform. This data platform will power a new collaborative IDE, and I’ll use this IDE to build board games. Board games are hard, and I love to play them. I’ve got my work cut out for me, but I’m having fun. I have embarrassingly launched: https://www.adama-platform.com/2022/03/02/early-access-launch-and-confession.html with an open strategy: https://www.adama-platform.com/2022/02/24/open-strategy.html . I’m currently in the phase of “how do I even describe this thing” to cross various chasms. Fortunately, I’m betting on the end artifacts over the coming decades as I expect board games to still in exist in 10+ years. I believe in mixing state and compute in a sane way, but this is exceptionally hard as you ultimately must build a database. At core, Adama enables people to DIY a real-time database. Fun enough, this work has connected me deeply to the Actor model as well as Alan Kay’s original meaning of object-orientated programming. A document with Adama is a siloed stateful object capable of receiving messages and emitting differential state updates to viewers.
    j
    w
    +1
    3 replies
    Copy to Clipboard
  • Carson Kahn

    Carson Kahn

    5 months ago
    Hey gang! 👋 I’m an insatiable learner, ML wonk, and product guy working on a low-code declarative framework for prescriptive analytics with my longtime friend and role model @Ryan Atallah. Having each founded/sold companies in this space previously, we’ve both been passionate about goals like “offloading cognition to perception” (Hullman & Kayongo) and “data applications that enhance human cognition” (nos) for literally as long as we can remember… 🤓 Both being engineers who started out as designers, @stevekrouse told us this was the perfect place to find likeminded folks! 🖖 We’re interested in highly-abstracted or novel approaches to constrained optimization (MIP, MINLP, statistical) and related operations research problems; visual analytics/IVA with direct manipulation & linked brushing; and techniques for modeling “assumptions as first-class citizens” in analytics & simulation settings. 🧮 Outside of our current work, we’re hobbyhorsically fascinated by explorable explanations, machine-assisted creativity, etc etc. 🙂 Looking forward to meeting more of you, and to learning from all of you! 🙏 P.S. Although it’s not relevant to my Ryan/my work on Spindle, here’s an HC simulator in the browser I’ve been enjoying lately, for all of us HyperCard :hypercard: nostalgiacs: hypercardsimulator.com (you can also convert old HyperCard stacks into JS/JSON with Dan’s ConvertHCStack)
    Carson Kahn
    c
    2 replies
    Copy to Clipboard
  • Jimmy Miller

    Jimmy Miller

    5 months ago
    I don’t think I ever actually introduced myself. I’m sure most of you have seen me around on some thread or other, but figured I should probably do this officially. If you listened to the latest episode, you will know me as a new cohost on the podcast. Super excited to join @Ivan Reese in getting to think through some ideas, read some old papers, talk about interesting concepts in the “future of coding”. But a bit about me. I do clojure for my day job, but have been loving rust lately. I love public speaking. I’ve got two talks on the youtubes about programming. One about a library a friend of mine made in clojure around term rewriting (the talk itself is pretty future of coding adjacent, if we crank that future to the nearer term). But also a talk about how philosophy of science relates to programming (Specifically are programming paradigms kuhnian paradigms). As for my views on future of coding things, I’m not really a partisan. I think the most exciting thing about the work we all do here is the breadth, the explorations, the diversity of views. I have my opinions of course. But I think the future of coding has to include lots of views, many of which aren’t for me. For my non-programming hobby, I love analytic philosophy. It is like the best parts of programming, but can be done in the armchair. Analytic philosophy is also very tied up in the history of computer science. The deeper you dive, the more similarities you find. Finally, since we are going to be reading a lot on the podcast, I plan on posting on #reading-together regularly about the papers we are reading and others (will post there later today about todays episode). I hope this can serve as a nice place to have conversations about the episodes and to help pick paper to talk about on future shows.
    Jimmy Miller
    s
    +3
    8 replies
    Copy to Clipboard