Pocket Calculator

  •        91

This is POC project that implements a simple WinForms Pocket Calculator that uses a Microsoft .NET 4.0.1 State Machine Workflow in the back-end.




Related Projects

CalculatorFSM - Calculator with Finite State Machine

Calculator with Finite State Machine

Spring Statemachine - Framework for application developers to use state machine concepts with Spring

Spring Statemachine is a framework for application developers to use state machine concepts with Spring applications. Hierarchical state machine, Usage of triggers, transitions, guards and actions, Type safe configuration adapter, Distributed state machine based on a Zookeeper, State machine event listeners and lot more.

state-machine - Finite state machine class generator for java, exports graphml, supports immutability!

Generates java classes to handle state transitions based on a state machine defined with type safety in java. Supports immutability (though is not opinionated in the sense that if you want to mutate your objects you can).Consider a microwave. If you were going to write the control system for a microwave you'd find it's a natural candidate for a state machine (actually all programming is working with state machines but we are going to work with one quite explicitly). We are going to work with a very simple microwave design (one you'd be crazy to buy in the shops!) just to demonstrate state diagrams.

pmcalc - Pocket money calculator (HSP Contest 2012 Ver.)

Pocket money calculator (HSP Contest 2012 Ver.)

pocket_calculator_kata - My solution to the Pocket Calculator Kata

My solution to the Pocket Calculator Kata

AriCalculator - A homemade pocket calculator

A homemade pocket calculator

StatefulJ - Event Driven Finite State Machine (FSM)

StatefulJ is a lightweight, open source Java Event Driven Finite State Machine(FSM) and a complete Spring Data based framework which lets you easily define and integrate State Machines into your Applications. It is simple, dependency free, in memory implementation of an FSM with support for concurrency and non-deterministic transitions.

SMC - The State Machine Compiler

SMC takes a state machine stored in a .sm file and generates a State pattern in 14 programming languages. Includes: default transitions, transition args, transition guards, push/pop transitions and Entry/Exit actions.

Finite State Machine Editor

A Finite State Machine Editor, written on QT. It allows to draw Finite State Machine with easy GUI and store it in XML file. There are Finite State Machine Compilers to translate this description to source code (technique like QT's UIC uses).

Simple State Machine

A simple state machine implementation written to replace WF in one of our projects. The interesting aspect of this library is that it comes with a DSL written in boo for quick and easy configuration and management of state machine definitions.

fysom - Finite State Machine for Python (based on Jake Gordon's javascript-state-machine)

Finite State Machine for Python (based on Jake Gordon's javascript-state-machine)

yaraft - Yet Another RAFT implementation

yaraft is a C++11 port of etcd/raft, which is a widely proven Raft library written in Go. Raft is a well-known distributed consensus algorithm. It's a practical solution designed for understandability, without sacrificing performance and fault-tolerance comparing to Paxos.etcd/raft features at its minimalistic design that only the core Raft protocol is implemented. No RPC, no WAL storage, no multi-threaded environment. It has nothing more than a pure state machine, so that we can test it in a deterministic way. For state machines with the same state, the same state machine input should always generate the same state machine output.


Smach is an open-source Scala library designed to support creation of functional, composable, streamable and recoverable state machines. Smach state machines can be composed together to form larger state machines or connected together to form a processing pipeline plan that can be run to produce a final value. Smach state machines also support a generic error recovery system (by way of the Halted state) that may be used to report errors encountered during processing by any composed or connected

Reactive State Machine

Reactive State Machine is a State Machine implementation based on Reactive Extensions. It plays nicely with the Visual State Manager of WPF.

micromachine - Minimal Finite State Machine

Minimal Finite State Machine.There are many finite state machine implementations for Ruby, and they all provide a nice DSL for declaring events, exceptions, callbacks, and all kinds of niceties in general.

Copycat - A novel implementation of the Raft consensus algorithm

Copycat is a fault-tolerant state machine replication framework. Built on the Raft consensus algorithm, it handles replication and persistence and enforces strict ordering of inputs and outputs, allowing developers to focus on single-threaded application logic. Its event-driven model allows for efficient client communication with replicated state machines, from simple key-value stores to wait-free locks and leader elections. You supply the state machine and Copycat takes care of the rest, making it easy to build robust, safe distributed systems.

go-fsm-example - An example FSM implementation in Go

The idea is simple, each state function returns the next state.```go// stateFn represents the state of the machine// as a function that returns the next state.type stateFn func(*fsm) stateFn```Then each state is defined as a function that receives a `*fsm` and return a `stateFn````gofunc idleState(f *fsm) stateFn {f.code = ""fmt.Printf("Enter code: ")return readState}```In this example I'm creating a fsm that verify some secret code.To represent the `done` state a `stateFn` must return `nil` and

OpenFst Library for constructing weighted finite-state transducer

OpenFst is a library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs). Weighted finite-state transducers are automata where each transition has an input label, an output label, and a weight. FSTs have key applications in speech recognition and synthesis, machine translation, optical character recognition, pattern matching, string processing, machine learning, information extraction and retrieval among others.

automaton - Friendly state machines for python.

Friendly state machines for python. The goal of this library is to provide well documented state machine classes and associated utilities. The state machine pattern (or the implemented variation there-of) is a commonly used pattern and has a multitude of various usages. Some of the usages for this library include providing state & transition validation and running/scheduling/analyzing the execution of tasks.

Finite State Machine (FSM)

This library is an implementation of an extensible dynamic configurable finite state machine (FSM). The configuration of the state machine is not compiled, but loaded at the runtime from a file or created by application.