single state assignment

Lesson 6: Static Single Assignment

• discussion thread
• static single assignment
• SSA slides from Todd Mowry at CMU another presentation of the pseudocode for various algorithms herein
• Revisiting Out-of-SSA Translation for Correctness, Code Quality, and Efficiency by Boissinot on more sophisticated was to translate out of SSA form
• tasks due March 8

You have undoubtedly noticed by now that many of the annoying problems in implementing analyses & optimizations stem from variable name conflicts. Wouldn’t it be nice if every assignment in a program used a unique variable name? Of course, people don’t write programs that way, so we’re out of luck. Right?

Wrong! Many compilers convert programs into static single assignment (SSA) form, which does exactly what it says: it ensures that, globally, every variable has exactly one static assignment location. (Of course, that statement might be executed multiple times, which is why it’s not dynamic single assignment.) In Bril terms, we convert a program like this:

Into a program like this, by renaming all the variables:

Of course, things will get a little more complicated when there is control flow. And because real machines are not SSA, using separate variables (i.e., memory locations and registers) for everything is bound to be inefficient. The idea in SSA is to convert general programs into SSA form, do all our optimization there, and then convert back to a standard mutating form before we generate backend code.

Just renaming assignments willy-nilly will quickly run into problems. Consider this program:

If we start renaming all the occurrences of a , everything goes fine until we try to write that last print a . Which “version” of a should it use?

To match the expressiveness of unrestricted programs, SSA adds a new kind of instruction: a ϕ-node . ϕ-nodes are flow-sensitive copy instructions: they get a value from one of several variables, depending on which incoming CFG edge was most recently taken to get to them.

In Bril, a ϕ-node appears as a phi instruction:

The phi instruction chooses between any number of variables, and it picks between them based on labels. If the program most recently executed a basic block with the given label, then the phi instruction takes its value from the corresponding variable.

You can write the above program in SSA like this:

It can also be useful to see how ϕ-nodes crop up in loops.

(An aside: some recent SSA-form IRs, such as MLIR and Swift’s IR , use an alternative to ϕ-nodes called basic block arguments . Instead of making ϕ-nodes look like weird instructions, these IRs bake the need for ϕ-like conditional copies into the structure of the CFG. Basic blocks have named parameters, and whenever you jump to a block, you must provide arguments for those parameters. With ϕ-nodes, a basic block enumerates all the possible sources for a given variable, one for each in-edge in the CFG; with basic block arguments, the sources are distributed to the “other end” of the CFG edge. Basic block arguments are a nice alternative for “SSA-native” IRs because they avoid messy problems that arise when needing to treat ϕ-nodes differently from every other kind of instruction.)

Bril in SSA

Bril has an SSA extension . It adds support for a phi instruction. Beyond that, SSA form is just a restriction on the normal expressiveness of Bril—if you solemnly promise never to assign statically to the same variable twice, you are writing “SSA Bril.”

The reference interpreter has built-in support for phi , so you can execute your SSA-form Bril programs without fuss.

The SSA Philosophy

In addition to a language form, SSA is also a philosophy! It can fundamentally change the way you think about programs. In the SSA philosophy:

• definitions == variables
• instructions == values
• arguments == data flow graph edges

In LLVM, for example, instructions do not refer to argument variables by name—an argument is a pointer to defining instruction.

Converting to SSA

To convert to SSA, we want to insert ϕ-nodes whenever there are distinct paths containing distinct definitions of a variable. We don’t need ϕ-nodes in places that are dominated by a definition of the variable. So what’s a way to know when control reachable from a definition is not dominated by that definition? The dominance frontier!

We do it in two steps. First, insert ϕ-nodes:

Then, rename variables:

Converting from SSA

Eventually, we need to convert out of SSA form to generate efficient code for real machines that don’t have phi -nodes and do have finite space for variable storage.

The basic algorithm is pretty straightforward. If you have a ϕ-node:

Then there must be assignments to x and y (recursively) preceding this statement in the CFG. The paths from x to the phi -containing block and from y to the same block must “converge” at that block. So insert code into the phi -containing block’s immediate predecessors along each of those two paths: one that does v = id x and one that does v = id y . Then you can delete the phi instruction.

This basic approach can introduce some redundant copying. (Take a look at the code it generates after you implement it!) Non-SSA copy propagation optimization can work well as a post-processing step. For a more extensive take on how to translate out of SSA efficiently, see “Revisiting Out-of-SSA Translation for Correctness, Code Quality, and Efficiency” by Boissinot et al.

• One thing to watch out for: a tricky part of the translation from the pseudocode to the real world is dealing with variables that are undefined along some paths.
• Previous 6120 adventurers have found that it can be surprisingly difficult to get this right. Leave yourself plenty of time, and test thoroughly.
• You will want to make sure the output of your “to SSA” pass is actually in SSA form. There’s a really simple is_ssa.py script that can check that for you.
• You’ll also want to make sure that programs do the same thing when converted to SSA form and back again. Fortunately, brili supports the phi instruction, so you can interpret your SSA-form programs if you want to check the midpoint of that round trip.
• For bonus “points,” implement global value numbering for SSA-form Bril code.

ENOSUCHBLOG

Programming, philosophy, pedaling., understanding static single assignment forms, oct 23, 2020     tags: llvm , programming    .

This post is at least a year old.

With thanks to Niki Carroll , winny, and kurufu for their invaluable proofreading and advice.

By popular demand , I’m doing another LLVM post. This time, it’s single static assignment (or SSA) form, a common feature in the intermediate representations of optimizing compilers.

Like the last one , SSA is a topic in compiler and IR design that I mostly understand but could benefit from some self-guided education on. So here we are.

How to represent a program

At the highest level, a compiler’s job is singular: to turn some source language input into some machine language output . Internally, this breaks down into a sequence of clearly delineated 1 tasks:

• Lexing the source into a sequence of tokens
• Parsing the token stream into an abstract syntax tree , or AST 2
• Validating the AST (e.g., ensuring that all uses of identifiers are consistent with the source language’s scoping and definition rules) 3
• Translating the AST into machine code, with all of its complexities (instruction selection, register allocation, frame generation, &c)

In a single-pass compiler, (4) is monolithic: machine code is generated as the compiler walks the AST, with no revisiting of previously generated code. This is extremely fast (in terms of compiler performance) in exchange for some a few significant limitations:

Optimization potential: because machine code is generated in a single pass, it can’t be revisited for optimizations. Single-pass compilers tend to generate extremely slow and conservative machine code.

By way of example: the System V ABI (used by Linux and macOS) defines a special 128-byte region beyond the current stack pointer ( %rsp ) that can be used by leaf functions whose stack frames fit within it. This, in turn, saves a few stack management instructions in the function prologue and epilogue.

A single-pass compiler will struggle to take advantage of this ABI-supplied optimization: it needs to emit a stack slot for each automatic variable as they’re visited, and cannot revisit its function prologue for erasure if all variables fit within the red zone.

Language limitations: single-pass compilers struggle with common language design decisions, like allowing use of identifiers before their declaration or definition. For example, the following is valid C++:

C and C++ generally require pre-declaration and/or definition for identifiers, but member function bodies may reference the entire class scope. This will frustrate a single-pass compiler, which expects Rect::width and Rect::height to already exist in some symbol lookup table for call generation.

Consequently, (virtually) all modern compilers are multi-pass .

Multi-pass compilers break the translation phase down even more:

• The AST is lowered into an intermediate representation , or IR
• Analyses (or passes) are performed on the IR, refining it according to some optimization profile (code size, performance, &c)
• The IR is either translated to machine code or lowered to another IR, for further target specialization or optimization 4

So, we want an IR that’s easy to correctly transform and that’s amenable to optimization. Let’s talk about why IRs that have the static single assignment property fill that niche.

At its core, the SSA form of any program source program introduces only one new constraint: all variables are assigned (i.e., stored to) exactly once .

By way of example: the following (not actually very helpful) function is not in a valid SSA form with respect to the flags variable:

Why? Because flags is stored to twice: once for initialization, and (potentially) again inside the conditional body.

As programmers, we could rewrite helpful_open to only ever store once to each automatic variable:

But this is clumsy and repetitive: we essentially need to duplicate every chain of uses that follow any variable that is stored to more than once. That’s not great for readability, maintainability, or code size.

So, we do what we always do: make the compiler do the hard work for us. Fortunately there exists a transformation from every valid program into an equivalent SSA form, conditioned on two simple rules.

Rule #1: Whenever we see a store to an already-stored variable, we replace it with a brand new “version” of that variable.

Using rule #1 and the example above, we can rewrite flags using _N suffixes to indicate versions:

But wait a second: we’ve made a mistake!

• open(..., flags_1, ...) is incorrect: it unconditionally assigns O_CREAT , which wasn’t in the original function semantics.
• open(..., flags_0, ...) is also incorrect: it never assigns O_CREAT , and thus is wrong for the same reason.

So, what do we do? We use rule 2!

Rule #2: Whenever we need to choose a variable based on control flow, we use the Phi function (φ) to introduce a new variable based on our choice.

Using our example once more:

Our quandary is resolved: open always takes flags_2 , where flags_2 is a fresh SSA variable produced applying φ to flags_0 and flags_1 .

Observe, too, that φ is a symbolic function: compilers that use SSA forms internally do not emit real φ functions in generated code 5 . φ exists solely to reconcile rule #1 with the existence of control flow.

As such, it’s a little bit silly to talk about SSA forms with C examples (since C and other high-level languages are what we’re translating from in the first place). Let’s dive into how LLVM’s IR actually represents them.

SSA in LLVM

First of all, let’s see what happens when we run our very first helpful_open through clang with no optimizations:

(View it on Godbolt .)

So, we call open with %3 , which comes from…a load from an i32* named %flags ? Where’s the φ?

This is something that consistently slips me up when reading LLVM’s IR: only values , not memory, are in SSA form. Because we’ve compiled with optimizations disabled, %flags is just a stack slot that we can store into as many times as we please, and that’s exactly what LLVM has elected to do above.

As such, LLVM’s SSA-based optimizations aren’t all that useful when passed IR that makes direct use of stack slots. We want to maximize our use of SSA variables, whenever possible, to make future optimization passes as effective as possible.

This is where mem2reg comes in:

This file (optimization pass) promotes memory references to be register references. It promotes alloca instructions which only have loads and stores as uses. An alloca is transformed by using dominator frontiers to place phi nodes, then traversing the function in depth-first order to rewrite loads and stores as appropriate. This is just the standard SSA construction algorithm to construct “pruned” SSA form.

(Parenthetical mine.)

mem2reg gets run at -O1 and higher, so let’s do exactly that:

Foiled again! Our stack slots are gone thanks to mem2reg , but LLVM has actually optimized too far : it figured out that our flags value is wholly dependent on the return value of our access call and erased the conditional entirely.

Instead of a φ node, we got this select :

which the LLVM Language Reference describes concisely:

The ‘select’ instruction is used to choose one value based on a condition, without IR-level branching.

So we need a better example. Let’s do something that LLVM can’t trivially optimize into a select (or sequence of select s), like adding an else if with a function that we’ve only provided the declaration for:

That’s more like it! Here’s our magical φ:

LLVM’s phi is slightly more complicated than the φ(flags_0, flags_1) that I made up before, but not by much: it takes a list of pairs (two, in this case), with each pair containing a possible value and that value’s originating basic block (which, by construction, is always a predecessor block in the context of the φ node).

The Language Reference backs us up:

The type of the incoming values is specified with the first type field. After this, the ‘phi’ instruction takes a list of pairs as arguments, with one pair for each predecessor basic block of the current block. Only values of first class type may be used as the value arguments to the PHI node. Only labels may be used as the label arguments. There must be no non-phi instructions between the start of a basic block and the PHI instructions: i.e. PHI instructions must be first in a basic block.

Observe, too, that LLVM is still being clever: one of our φ choices is a computed select ( %spec.select ), so LLVM still managed to partially erase the original control flow.

So that’s cool. But there’s a piece of control flow that we’ve conspicuously ignored.

What about loops?

Not one, not two, but three φs! In order of appearance:

Because we supply the loop bounds via count , LLVM has no way to ensure that we actually enter the loop body. Consequently, our very first φ selects between the initial %base and %add . LLVM’s phi syntax helpfully tells us that %base comes from the entry block and %add from the loop, just as we expect. I have no idea why LLVM selected such a hideous name for the resulting value ( %base.addr.0.lcssa ).

Our index variable is initialized once and then updated with each for iteration, so it also needs a φ. Our selections here are %inc (which each body computes from %i.07 ) and the 0 literal (i.e., our initialization value).

Finally, the heart of our loop body: we need to get base , where base is either the initial base value ( %base ) or the value computed as part of the prior loop ( %add ). One last φ gets us there.

The rest of the IR is bookkeeping: we need separate SSA variables to compute the addition ( %add ), increment ( %inc ), and exit check ( %exitcond.not ) with each loop iteration.

So now we know what an SSA form is , and how LLVM represents them 6 . Why should we care?

As I briefly alluded to early in the post, it comes down to optimization potential: the SSA forms of programs are particularly suited to a number of effective optimizations.

Let’s go through a select few of them.

Dead code elimination

One of the simplest things that an optimizing compiler can do is remove code that cannot possibly be executed . This makes the resulting binary smaller (and usually faster, since more of it can fit in the instruction cache).

“Dead” code falls into several categories 7 , but a common one is assignments that cannot affect program behavior, like redundant initialization:

Without an SSA form, an optimizing compiler would need to check whether any use of x reaches its original definition ( x = 100 ). Tedious. In SSA form, the impossibility of that is obvious:

And sure enough, LLVM eliminates the initial assignment of 100 entirely:

Constant propagation

Compilers can also optimize a program by substituting uses of a constant variable for the constant value itself. Let’s take a look at another blob of C:

As humans, we can see that y and z are trivially assigned and never modified 8 . For the compiler, however, this is a variant of the reaching definition problem from above: before it can replace y and z with 7 and 10 respectively, it needs to make sure that y and z are never assigned a different value.

Let’s do our SSA reduction:

This is virtually identical to our original form, but with one critical difference: the compiler can now see that every load of y and z is the original assignment. In other words, they’re all safe to replace!

So we’ve gotten rid of a few potential register operations, which is nice. But here’s the really critical part: we’ve set ourselves up for several other optimizations :

Now that we’ve propagated some of our constants, we can do some trivial constant folding : 7 + 10 becomes 17 , and so forth.

In SSA form, it’s trivial to observe that only x and a_{1..4} can affect the program’s behavior. So we can apply our dead code elimination from above and delete y and z entirely!

This is the real magic of an optimizing compiler: each individual optimization is simple and largely independent, but together they produce a virtuous cycle that can be repeated until gains diminish.

Register allocation

Register allocation (alternatively: register scheduling) is less of an optimization itself , and more of an unavoidable problem in compiler engineering: it’s fun to pretend to have access to an infinite number of addressable variables, but the compiler eventually insists that we boil our operations down to a small, fixed set of CPU registers .

The constraints and complexities of register allocation vary by architecture: x86 (prior to AMD64) is notoriously starved for registers 9 (only 8 full general purpose registers, of which 6 might be usable within a function’s scope 10 ), while RISC architectures typically employ larger numbers of registers to compensate for the lack of register-memory operations.

Just as above, reductions to SSA form have both indirect and direct advantages for the register allocator:

Indirectly: Eliminations of redundant loads and stores reduces the overall pressure on the register allocator, allowing it to avoid expensive spills (i.e., having to temporarily transfer a live register to main memory to accommodate another instruction).

Directly: Compilers have historically lowered φs into copies before register allocation, meaning that register allocators traditionally haven’t benefited from the SSA form itself 11 . There is, however, (semi-)recent research on direct application of SSA forms to both linear and coloring allocators 12 13 .

A concrete example: modern JavaScript engines use JITs to accelerate program evaluation. These JITs frequently use linear register allocators for their acceptable tradeoff between register selection speed (linear, as the name suggests) and acceptable register scheduling. Converting out of SSA form is a timely operation of its own, so linear allocation on the SSA representation itself is appealing in JITs and other contexts where compile time is part of execution time.

There are many things about SSA that I didn’t cover in this post: dominance frontiers , tradeoffs between “pruned” and less optimal SSA forms, and feedback mechanisms between the SSA form of a program and the compiler’s decision to cease optimizing, among others. Each of these could be its own blog post, and maybe will be in the future!

In the sense that each task is conceptually isolated and has well-defined inputs and outputs. Individual compilers have some flexibility with respect to whether they combine or further split the tasks.  ↩

The distinction between an AST and an intermediate representation is hazy: Rust converts their AST to HIR early in the compilation process, and languages can be designed to have ASTs that are amendable to analyses that would otherwise be best on an IR.  ↩

This can be broken up into lexical validation (e.g. use of an undeclared identifier) and semantic validation (e.g. incorrect initialization of a type).  ↩

This is what LLVM does: LLVM IR is lowered to MIR (not to be confused with Rust’s MIR ), which is subsequently lowered to machine code.  ↩

Not because they can’t: the SSA form of a program can be executed by evaluating φ with concrete control flow.  ↩

We haven’t talked at all about minimal or pruned SSAs, and I don’t plan on doing so in this post. The TL;DR of them: naïve SSA form generation can lead to lots of unnecessary φ nodes, impeding analyses. LLVM (and GCC, and anything else that uses SSAs probably) will attempt to translate any initial SSA form into one with a minimally viable number of φs. For LLVM, this tied directly to the rest of mem2reg .  ↩

Including removing code that has undefined behavior in it, since “doesn’t run at all” is a valid consequence of invoking UB.  ↩

And are also function scoped, meaning that another translation unit can’t address them.  ↩

x86 makes up for this by not being a load-store architecture : many instructions can pay the price of a memory round-trip in exchange for saving a register.  ↩

Assuming that %esp and %ebp are being used by the compiler to manage the function’s frame.  ↩

LLVM, for example, lowers all φs as one of its very first preparations for register allocation. See this 2009 LLVM Developers’ Meeting talk .  ↩

Wimmer 2010a: “Linear Scan Register Allocation on SSA Form” ( PDF )  ↩

Hack 2005: “Towards Register Allocation for Programs in SSA-form” ( PDF )  ↩

• Engineering Mathematics
• Discrete Mathematics
• Operating System
• Computer Networks
• Digital Logic and Design
• C Programming
• Data Structures
• Theory of Computation
• Compiler Design
• Computer Org and Architecture

State Reduction and State Assignment

To illustrate the process of state reduction and state assignment first we have to know the concepts of the state diagram, state table, and state equation. In this article, we are going to learn all the topics related to state reduction and assignment.

State diagram: The state graph or state diagram is a pictorial representation of the relationships between the present state, the input state, the next state, and the output state of a sequential circuit i.e. A state diagram is a graphical representation of a sequential circuit’s behavior.

Example: Consider an excitation table of J-K flip-flop 

The state diagram of the above table is 

State Diagram of J-K flip-flop 

State table: Even though the behavior of a sequential circuit can be conveniently described using a state diagram, for its implementation the information contained in the state diagram is to be translated into a state table. The tabular form of the state diagram is the state table. The present state, the next state, and the output are the three sections of the diagram.

The state table of JK flip-flop is:

State equation: Q n+1 = Q n bar J + Q n K bar

State reduction: 

The state reduction technique generally prevents the addition of duplicate states. The reduction in redundant states reduces the number of flip-flops and logic gates,  reducing the cost of the final circuit. Two states are said to be equivalent if every possible set of inputs generates exactly the same output and the same next state. When two states are equal, one of them can be eliminated without changing the input-output relationship. The state reduction algorithm is applied in the state table to reduce equivalent states.  

State assignment: 

State assignment refers to the process of assigning binary values to the states of a sequential machine. The binary values should be given to the states in such a way that flip-flop input functions may be implemented with a minimum number of logic gates.

State assignment rules are as follows:

Rule 1: States having the same next state for a given input condition should have assignments that can be grouped into logically adjacent cells in a K-map. 

Rule 2: States that are the next states of a single state should have assignments that can be grouped into logically adjacent cells in a K-map.

Example 1: To explain the concept of state reduction let us consider the state table as 

The state diagram for the above state table is 

State diagram before reduction

Step1: First here we are supposed to identify two or more similar states in the next state and output state. In the above table if we observe states of e and g are having the same next state and output values for all combinations of input i.e. X=0 and X=1.

So eliminate the g state in the state table and wherever g is present replace it with e. Because e and g both are the same i.e. e=g. 

Step 2: Again check if any two states have similar values or not. If any two states have the same next state and output then eliminate one state. 

Here d and f are having the same next state value and output. So eliminate f and wherever f is present replace it with d. Because both are the same d=f

Step 3: Further observe if any similar states are present or not. The states c and e are having same next states but they are having different outputs. So we can not consider it a reduction state. 

State diagram After reduction

Step 4:   If you observed the state table, the states are represented by using the alphabet. We can not proceed further if we are having alphabets, so, assigning binary numbers to alphabets is called a state assignment.  

To assign binary numbers to the state we have to consider the minimum number of bits. 

The codes must contain n bits for a circuit with m states, where 2 n >= m. In this case, each state requires 2 3 >=5=>3 bits to be represented. With three bits, there are eight possible combinations, of which five can be used to represent the states.

Step 5: Replacing the alphabets with binary numbers. 

Please Login to comment...

Similar reads.

• Computer Subject
• Digital Logic

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

What is the purpose of single assignment?

I'm currently trying to master Erlang. It's the first functional programming language that I look into and I noticed that in Erlang, each assignments that you do is a single assignment. And apparently, not just in Erlang, but in many other functional programming languages, assignments are done through single assignment.

I'm really confused about why they made it like that. What exactly is the purpose of single assignment? What benefits can we get from it?

• functional-programming

• I suggest checking this answer . In short, it's not an assignment as such; it's a name binding process. –  raina77ow Commented Jun 29, 2012 at 3:30
• Probably a better fit for Software Engineering . –  user244343 Commented Jun 29, 2012 at 3:49
• The answers to this question may be more to the point. –  Andreas Rossberg Commented Jun 29, 2012 at 9:32

3 Answers 3

Immutability (what you call single assignment), simplifies a lot of things because it takes out the "time" variable from your programs.

For example, in mathematics if you say

You can replace x for y , everywhere. In operational programming languages you can't ensure that this equality holds: there is a "time" (state) associated with each line of code. This time state also leaves the door open to undesired side effects which is the enemy number one of modularity and concurrency.

For more information see this.

Because of Single Assignment , Side effects are so minimal. Infact, its so hard to write code with race conditions or any side effects in Erlang. This is because, the Compiler easilly tells un-used variables, created terms which are not used, shadowed variables (especially inside funs ) e.t.c. Another advantage that Erlang gained in this is Referential Transparency . A function in Erlang will depend only on the variables passed to it and NOT on global variables, except MACROS (and macros cannot be changed at run-time, they are constants.). Lastly, if you watched the Erlang Movie , the Sophisticated Error Detection Mechanism which was built into Erlang depends so much on the fact that in Erlang, variables are assigned Once.

• 2 Note, however, that functions in Erlang aren't completely referentially transparent: sending a message to another process may result in side-effects which change the value of future calls to the function. As for global variables, there's the process dictionary, ETS tables and the like. –  Martin Törnwall Commented Jun 29, 2012 at 17:31
• 1 Yes, Erlang is not at all referentially transparent, and immutability removes only one side effect (namely editing memory that might change the state of the world), but does nothing to limit side effects in general. –  Magnus Kronqvist Commented Jul 2, 2012 at 21:59

Having variables keep their values makes it much easier to understand and debug the code. With concurrent processes you get the same kind of problem anyway, so there is enough complication anyway without having just any variable potentially change its value at any time. Think of it as encapsulating side effects by only allowing them when explicit.

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged functional-programming erlang or ask your own question .

• Featured on Meta
• We spent a sprint addressing your requests — here’s how it went
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network...
• The [lib] tag is being burninated
• What makes a homepage useful for logged-in users

Hot Network Questions

• Did Joe Biden refer to himself as a black woman?
• How do Japanese kept up with the current loanwords
• Recommend an essay, article, entry, author, or branch of philosophy that addresses the futility of arguing for or against free will
• How to arrange three identical habitable planets in one solar system in similar or, if possible, same orbit?
• Is the variance of the mean of a set of possibly dependent random variables less than the average of their respective variances?
• Rolling median of all K-length ranges
• How do we define addition?
• Why does Google Maps only rotate 90º but not 180º when I rotate my iPhone?
• Is "sinnate" a word? What does it mean?
• Proof by Contradiction: "Bad Form" or "Finest Weapon"? Reconciling Perspectives
• Why the number of bits or bytes is different for a folder that has been copied between two external drives?
• Why do Electric Aircraft Seem to Eschew Photovoltaics?
• climate control and carbon sequestration via bulk air liquification
• How is 11:22 four minutes slow if it's actually 11:29?
• Offline, multi-machine, 2-factor authentication information vault?
• The rise and fall of oval chainrings?
• What is this rectangular SMD part with a stripe along one of the long edges?
• Filling the areas enclosed by two curves and calculate them
• How can I power both sides of breaker box with two 120 volt battery backups?
• If someone clearly believes that he has witnessed something extraordinary very clearly, why is it more reasonable to believe that they hallucinated?
• Are there dedicated research facilities in the USA?
• Looking for the title of a short story for my students to read about a woman searching for the last man alive
• Have human infant foreskins been put into commercial cosmetic products?
• Attaching foam to the bottom of a PCB

• Administering Fast Formulas

Overview of Using Fast Formula Components

When you're developing a fast formula, you must understand the formula language, the rules that the application imposes on the fast formula, and the calculation requirements.

Create fast formulas using these components:

Assignment statements

Return statements

Input statements

Expressions

Let's look at an example to understand how each component is used in a fast formula. Suppose you want to calculate the pay value for the WAGE element by multiplying the number of hours an employee works each week by the hourly rate. Here's how you can write the formula in this example:

Assignment Statements

An assignment statement assigns a value to the WAGE element.

Return Statements

A return statement passes the WAGE value back to the payroll run. You can use a return statement to stop the formula execution without passing any values.

Variables are of these classes:

Input variables appear in INPUTS statements and bring values into a fast formula.

Output variables appear in RETURN statements and return values from a fast formula. A variable can be both an input and output.

Local variables are only used within one formula.

You can change a local variable within the formula by assigning a value to it using an assignment statement. To calculate the WAGE value, the fast formula needs to get the value for the HOURS_WORKED variable .

You can use local variables to store data in a fast formula. You might want to hold data temporarily while you perform some other calculations, or pass data back to the application. Here's an example of the ANNUAL_LEAVE variable.

Input Statements

You can use HOURS_WORKED as an input value of the WAGE element. To pass the element input values to the fast formula during processing, define an input statement like this:

Each function or calculation is one expression. You can nest expressions to create more complex calculations. You can use brackets to control the order in which calculations are done.

The formula evaluates expressions within the brackets first. Within nested brackets, evaluation proceeds from the least inclusive set to the most inclusive set. If you don't use brackets, the formula evaluates expression in this order:

Multiplication, Division

Addition, Subtraction

Expressions combine constants and variables with operators (+, -, *, /), array methods, and functions to return a value of a certain data type. For example, the expression (3 + 2) returns a value of 5, and is a NUMBER data type. The format of an expression is:

You can combine a number of sub-expressions into a single expression. For example, you can combine the sub-expressions (3 + 2) and MONTHS_BETWEEN (start_date, end_date) into a single expression as follows:

You can also use expressions inside functions, such as:

Operands in an expression are usually of the same data type, which is the data type of the expression as a whole. Here's an example of an expression in which all the operands are numeric and the expression itself is numeric:

BONUS is the operand for the above expression. The return value is GREATEST . The arguments for GREATEST are separate expressions.

You can use conditions to process expressions based on whether a certain condition occurs. For example:

This formula checks if the condition (AGE < 20) is true or false. If it's true, the formula processes the statement that follows the word THEN . If the condition is false, the formula ignores this statement.

Use comments to explain all or part of a fast formula. Also, you can change some formula lines into comments until they're ready to be used. You can place comments anywhere within a formula. The beginning of a fast formula should contain these comments:

The formula title and a short purpose statement.

A description of the formula inputs.

A list of variables and literals that may require updating.

An explanation of the formula's calculation.

The dates of any modifications, the name of the person modifying the formula, and the reason for the change.

Multi-Line Comments

Multi-line comments are designated by the comment delimiters of /* and */. Anything written inside these delimiters is a comment.

Single Line Comments

Fast formula also supports single line comments. The # character is used for the start of single line comments. The # character itself and any text after it to the end of the line are ignored.

Comments Example:

• Moscow Oblast
•  » 
• Elektrostal

State Housing Inspectorate of the Moscow Region

Phone 8 (496) 575-02-20 8 (496) 575-02-20

Phone 8 (496) 511-20-80 8 (496) 511-20-80

Public administration near State Housing Inspectorate of the Moscow Region

• Games & Quizzes
• History & Society
• Science & Tech
• Biographies
• Animals & Nature
• Geography & Travel
• Arts & Culture
• On This Day
• One Good Fact
• New Articles
• Lifestyles & Social Issues
• Philosophy & Religion
• Politics, Law & Government
• World History
• Health & Medicine
• Browse Biographies
• Birds, Reptiles & Other Vertebrates
• Bugs, Mollusks & Other Invertebrates
• Environment
• Fossils & Geologic Time
• Entertainment & Pop Culture
• Sports & Recreation
• Visual Arts
• Demystified
• Image Galleries
• Infographics
• Top Questions
• Britannica Kids
• Saving Earth
• Space Next 50
• Student Center

Elektrostal

Our editors will review what you’ve submitted and determine whether to revise the article.

Elektrostal , city, Moscow oblast (province), western Russia . It lies 36 miles (58 km) east of Moscow city. The name, meaning “electric steel,” derives from the high-quality-steel industry established there soon after the October Revolution in 1917. During World War II , parts of the heavy-machine-building industry were relocated there from Ukraine, and Elektrostal is now a centre for the production of metallurgical equipment. Pop. (2006 est.) 146,189.

trending now in Lifestyle

Historic tourist attraction loses $170K worth of donations after...

Drinking just one alcoholic beverage per day shortens your...

Family's $444 receipt from Trader Joe's goes viral on social...

Dear Abby: Should I skip my daughter's graduation if my wife...

Men keep hitting on me at the gym, then I turn around and they...

Study reveals the real reason women masturbate — and how often...

‘I’m such a brat’: Woman sobs after admitting she ordered...

These are the 3 cheapest, safest cities on the West Coast —...

These people saw it was time to make a bold career move — could you.

• View Author Archive
• Get author RSS feed

Thanks for contacting us. We've received your submission.

When Superstorm Sandy hit in October 2012, it wiped out much of Jarad and Christel Astin’s Far Rockaway, New York, ground-floor apartment. They did, however, salvage the 22-foot sailboat, and it became a symbolic part of their life-altering change of course.

Jarad, then 47, was burned out with his live animal curator job at the Brooklyn Children’s Museum , while simultaneously gigging as a musician and singer. Christel, age 49, was a flautist in the Irish music world and taught at the New York Irish Arts Center .

“Financially, it was difficult,” Jarad said, as the couple were raising two young daughters, ages 2 and 11 at the time.

Although they had dreamed of living abroad once they retired, “we started legitimately kicking around the idea of sailing full time,” said Jarad. “It was a moment of freedom.”

To turn vision into action, in November 2013 the Astins raised $60,000 from their family, purchased a larger yacht, joined a sailing rally and left for the Caribbean with just one music gig booked in advance.

Their first year was the most challenging, said Jarad, as they sailed through stormy waters, homeschooled their girls on their houseboat and landed venues to book their acoustic-gypsy-soul musical act.

“A lot of people who do things like this sell their home and apply the profit to a new life-style. We weren’t in that position. We had to find work. It was all or nothing — we had to show up and old-school hustle,” he said.

In 2017, after hurricanes Irma and Maria destroyed some of the lucrative establishments the duo performed at, Jarad earned his captain’s license for extra income. “We worked with sailing regattas, returning north in the summertime to launch Yacht Rock Charters , a leisure boat charter business in Jamaica Bay, NY.”

For Christel, the time and closeness their family unit has been afforded has been a bonus.

“When working three jobs and taking the kids from one extracurricular to the next, we didn’t have the luxury of time together, or for the self. I can take a walk on the beach now, or snorkel the shore. I have space to be outside with nature in an intimate way. It’s magic for me,” she said.

To others, she advised, “The whole manifesting your life is real. Make a tangible plan. Make it accessible. Start small and work your way up. Take the leap. For us we bought a little sailboat and said, we’re going to learn how to do this.”

If you’re also looking to make a big change, don’t get lost in the big picture. “Think of the one thing you can do today to get you closer tomorrow, three months from now, in your ideal state,” said Luck Dookchitra, vice president of people at Leapsome , a cloud-based people management software system which helps organizations drive employee engagement, performance and learning.

For example, to change careers from human resources to acting, “Can you take an acting class? Talk to those in the field. What will it cost? Framing the journey you’ll need to take will encourage you to make a move,” said Dookchitra.

Finding a way to exit her dream job as senior fashion editor for Cosmopolitan became important for Hudson Valley, NY, resident Amri Kibbler, 49, once she became a mom.

“My first daughter was 2 at the time, and I thought it would be a snap to have a second, but ran into secondary fertility issues. I was doing IVF when I decided to make a big life change. The stress of my fast-paced lifestyle wasn’t conducive to getting pregnant,” she said.

Kibbler sought a “higher purpose,” ultimately co-founding HeyMama , a membership-only online platform and community for women to share and connect on balancing motherhood with work.

“Our tagline is, ‘The juggle is real,’” said Kibbler. “I treated it as a full-time job, worked regular hours and it spread from there. We were recently acquired. Going forward, we’re launching a new platform with new, enhanced features.”

The main advice Kibbler got was not to wait, but to just get started.

“We started our Instagram account wanting 1,000 followers, then reached 2,000 and 10,000. You need bite-sized goals and tangible benchmarks. I had a goal for the week instead of trying to zigzag back and forth,” she said.

According to Dookchitra, when making a change, you may be inspired to work for yourself, to build something great related to your passion, or that’s more creative or with your name on it. “The way the world works now lends itself to more people finding happiness and satisfaction in life rather than separating it.”

When forging ahead in a new life, though, it’s essential to have a Plan A and B.

“Any good business leader thinks through these things,” said Dookchitra. “Find a partner or coach to spar with and raise any concerns. Think of the purpose of your bold move. Have a 360 view of why you want to switch careers or start a business. Be aware of the circumstances you’re in. Have a realistic timeline to minimize unhappy surprises and be fiscally responsible.”

Importantly, when leaving your current role, don’t burn bridges.

“If you have a good career, be thoughtful of how you communicate, as you may need a safety net to go back to,” advised Dookchitra.

For Beth Nydick , 51, of Livingston, NJ, tragedy shifted her entire work outlook and pursuits.

“I’d been a food blogger, featured on ‘Dr. Oz’ and ‘The Chew’. My hit cocktail book was promoted on Oprah. Then, in the same month, I was in a near-fatal car accident and my father-in-law was hit by a pickup truck — he passed away a few days later. I was shaken,” said Nydick.

She was left feeling that she wanted to do something more “than offering up another chili recipe.” In 2020, after seeing a therapist and attending a group coaching program, she established a public relations firm.

“I know how to help people show up fully as themselves, or have the confidence to go on live TV, or on speak on a TED X stage,” said Nydick, who is currently building the F.A.M.E. Lab , a live group coaching program for people to come learn and be supported to do big, bold things.

“You create your own possibility of success or failure. It’s up to you to take action,” said Nydick. “There will always be someone to tell you the reasons you shouldn’t, versus the why not me?”

Advertisement

• High Schools
• Mitch Albom
• Jeff Seidel
• Shawn Windsor
• Motorsports
• Detroit Marathon
• SportsbookWire

Detroit Tigers prospect Jackson Jobe completes rehab assignment, returns to Double-A Erie

CINCINNATI —  Detroit Tigers prospect Jackson Jobe has completed his rehab assignment.

The 21-year-old flamethrower has returned to Double-A Erie, been activated from the injured list and is scheduled to start Friday for the SeaWolves at UPMC Park in Erie, Pennsylvania. He completed three rehab starts with High-A West Michigan in his recovery from a left hamstring strain .

Jobe suffered the left hamstring strain May 1 , then spent more than two months on the injured list leading up to Friday's return. The right-hander ranks as the top pitching prospect in baseball, according to MLB Pipeline .

MORE ABOUT HIM: How Tigers' Jackson Jobe developed into top pitching prospect nearing MLB debut

Before the injury, Jobe posted a 2.16 ERA with 10 walks and 24 strikeouts across 16⅔ innings in five starts for Double-A Erie. He hadn't completed more than four innings in a single start.

Jobe, who turns 22 on July 30, registered a 2.00 ERA with two walks and eight strikeouts across nine innings in three starts with High-A West Michigan. He competed two innings on 29 pitches June 18, three innings on 32 pitches June 23 and four innings on 60 pitches June 29.

He threw a career-high 90 pitches on Aug. 30, 2023.

WHAT HAPPENS NEXT?: Innings plan for Tigers prospect Jackson Jobe won't be impacted by hamstring injury

The Tigers selected Jobe with the No. 3 overall pick in the 2021 draft . He also missed  several months with a back injury last season, in which he had a 2.82 ERA with 11 walks and 103 strikeouts across 79⅔ innings in 20 starts.

[ MUST LISTEN: Make "Days of Roar" your go-to Detroit Tigers podcast, available anywhere you listen to podcasts ( Apple , Spotify ) ]

Contact Evan Petzold at  [email protected]  or follow him  @EvanPetzold .

Listen to our weekly Tigers show  "Days of Roar"  every Monday afternoon on demand at freep.com,  Apple ,  Spotify  or wherever you listen to podcasts. And catch all of our podcasts and daily voice briefing at  freep.com/podcasts .