47-room hotel <strong>Sonesta</strong> opens Red Lion Inn &amp; Suites Elk Grove

Sonesta opens Red Lion Inn & Suites Elk Grove - hotelbusiness.com

Sonesta International Hotels Corporation (Sonesta) today announced the launch of Travel SOS (Sonesta Overnight Stay), a new service designed to alleviate stress experienced by stranded travelers during the busy holiday season.

Sonesta Offers a Lifeline for Travelers This 'Holi-Delay' Season

Planning a trip to this vibrant Midwestern city can be overwhelming with numerous options, leaving you wondering where to stay for an unforgettable

10 Best Hotels in St. Louis

LightHouse Hotels and Resorts recently acquired the 140-room Radisson Cleveland Airport West at 25070 Country Club Blvd. in North Olmsted.

North Olmsted’s Radisson Cleveland Airport West sold to LightHouse Hotels and Resorts

The state of Florida is a common vacation destination. WIth 4,514 hotels in total spread across 267 cities and 570 beaches. Florida is a safe state to travel to and has mild temperatures all year round averaging 72.1 F (21 C), making it a haven for surfing ...

The Best Hotels in Florida

Sonesta International Hotels Corp. has named former IHG Hotels & Resorts executive Bob Gunkel its new chief financial officer, effective immediately.

Sonesta Names Former IHG Exec CFO

Choice Hotels on Wednesday called on Wyndham to return to merger talks while publicly responding to concerns about "execution risk."

Choice Hotels Claims Wyndham Merger Would Have ‘Clear Path to Completion’

All-inclusive resorts don't have to break a traveler's budget; these are the cheapest resorts in the world for a fabulous and affordable vacation.

10 Of The Cheapest Resorts In The Entire World

Hotels in the New Orleans French Quarter One of New Orleans ... Situated in the heart of the French Quarter on Bourbon Street, the Royal Sonesta New Orleans puts you in the center of all the action with a luxury touch. Located just minutes from Jackson ...

8 Family-Friendly Hotels in New Orleans for Big Fun in the Big Easy

When getting around Fort Lauderdale, try Ride Circuit, a free ride app, the Brightline high-speed rail, and the Water Taxi for a fun and scenic tour.

A Complete, Year-Round 48-Hour Guide To Fort Lauderdale

Sonesta Hotels

sonesta

In of this series on the oclif testing library, we used a test-driven development approach to building our CLI. We talked about the , which helps developers dispense with the setup and boilerplate so that they can get to writing the meat of their CLI applications. Part One time-tracker oclif framework We also talked about and , which take care of the repetitive setup and teardown so that developers can focus on writing their Mocha tests. @oclif/test @oclif/fancy-test Our application is a . We’ve already written tests and implemented our first command for adding a new project to our tracker. Next, we’re going to write tests and implement our “start timer” command. time-tracker multi-command CLI Just as a reminder, the final application is posted on as a reference in case you hit a roadblock. GitHub First Test for the Start Timer Command Now that we can add a new project to our time tracker, we need to be able to start the timer for that project. The command usage would look like this: time-tracker start-timer project-one Since we’re taking a TDD approach, we’ll start by writing the test. For our happy path test,  "project-one" already exists, and we can simply start the timer for it. // PATH: test/commands/start-timer.test.js

const {expect, test} = require('@oclif/test')
const StartTimerCommand = require('../../src/commands/start-timer')
const MemoryStorage = require('../../src/storage/memory')
const {generateDb} = require('../test-helpers')

const someDate = 1631943984467

describe('start timer', () => {
  test
  .stdout()
  .stub(StartTimerCommand, 'storage', new MemoryStorage(generateDb('project-one')))
  .stub(Date, 'now', () => someDate)
  .command(['start-timer', 'project-one'])
  .it('should start a timer for "project-one"', async ctx => {
    expect(await StartTimerCommand.storage.load()).to.eql({
      activeProject: 'project-one',
      projects: {
        'project-one': {
          activeEntry: 0,
          entries: [
            {
              startTime: new Date(someDate),
              endTime: null,
            },
          ],
        },
      },
    })
    expect(ctx.stdout).to.contain('Started a new time entry on "project-one"')
  })
}) There is a lot of similarity between this test and the first test of our “add project” command. One difference, however, is the additional call. Since we will start the timer with , our test code will preemptively stub out to return . Though we don’t care what the value of is, what’s important is that it is fixed. stub() new Date(Date.now()) Date.now() someDate someDate When we run our test, we get the following error: Error: Cannot find module '../../src/commands/start-timer' It’s time to write some implementation code! Beginning to Implement the Start Time Command We need to create a file for our command. We duplicate the file and rename it as . We clear out most of the method, and we rename the command class to . start-timer add-project.js start-timer.js run StartTimerCommand const {Command, flags} = require('@oclif/command')
const FilesystemStorage = require('../storage/filesystem')

class StartTimerCommand extends Command {
  async run() {
    const {args} = this.parse(StartTimerCommand)
    const db = await StartTimerCommand.storage.load()

    await StartTimerCommand.storage.save(db)
  }
}

StartTimerCommand.storage = new FilesystemStorage()

StartTimerCommand.description = `Start a new timer for a project`

StartTimerCommand.flags = {
  name: flags.string({char: 'n', description: 'name to print'}),
}

module.exports = StartTimerCommand Now, when we run the test again, we see that the has not been updated as we had expected. db 1) start timer
       should start a timer for "project-one":

      AssertionError: expected { Object (activeProject, projects) } to deeply equal { Object (activeProject, projects) }
      + expected - actual

       {
      -  "activeProject": [null]
      +  "activeProject": "project-one"
         "projects": {
           "project-one": {
      -      "activeEntry": [null]
      -      "entries": []
      +      "activeEntry": 0
      +      "entries": [
      +        {
      +          "endTime": [null]
      +          "startTime": [Date: 2021-09-18T05:46:24.467Z]
      +        }
      +      ]
           }
         }
       }

      at Context.<anonymous> (test/commands/start-timer.test.js:16:55)
      at async Object.run (node_modules/fancy-test/lib/base.js:44:29)
      at async Context.run (node_modules/fancy-test/lib/base.js:68:25) While we’re at it, we also know that we should be logging something to tell the user what just happened. So let's update the run method with code to do that. const {args} = this.parse(StartTimerCommand)
const db = await StartTimerCommand.storage.load()

if (db.projects && db.projects[args.projectName]) {
	db.activeProject = args.projectName
	// Set the active entry before we push so we can take advantage of the fact
	// that the current length is the index of the next insert
	db.projects[args.projectName].activeEntry = db.projects[args.projectName].entries.length
	db.projects[args.projectName].entries.push({startTime: new Date(Date.now()), endTime: null})
}

this.log(`Started a new time entry on "${args.projectName}"`)

await StartTimerCommand.storage.save(db) Running the test again, we see that our tests are all passing! add project
    ✓ should add a new project
    ✓ should return an error if the project already exists (59ms)

start timer
    ✓ should start a timer for "project-one" Sad Path: Starting a Timer on a Non-Existent Project Next, we should notify the user if they attempt to start a timer on a project that doesn't exist. Let's start by writing a test for this. test
  .stdout()
  .stub(StartTimerCommand, 'storage', new MemoryStorage(generateDb('project-one')))
  .stub(Date, 'now', () => someDate)
  .command(['start-timer', 'project-does-not-exist'])
  .catch('Project "project-does-not-exist" does not exist')
  .it('should return an error if the user attempts to start a timer on a project that doesn\'t exist', async _ => {
    // Expect that the storage is unchanged
    expect(await StartTimerCommand.storage.load()).to.eql({
      activeProject: null,
      projects: {
        'project-one': {
          activeEntry: null,
          entries: [],
        },
      },
    })
  }) And, we are failing again. 1 failing

  1) start timer
       should return an error if the user attempts to start a timer on a project that doesn't exist:
     Error: expected error to be thrown
      at Object.run (node_modules/fancy-test/lib/catch.js:8:19)
      at Context.run (node_modules/fancy-test/lib/base.js:68:36) Let's write some code to fix that error. We add the following snippet of code to the beginning of the method, right after we load the from storage. run db if (!db.projects?.[args.projectName]) {
	this.error(`Project "${args.projectName}" does not exist`)
} We run the tests again. add project
    ✓ should add a new project (47ms)
    ✓ should return an error if the project already exists (75ms)

start timer
    ✓ should start a timer for "project-one"
    ✓ should return an error if the user attempts to start a timer on a project that doesn't exist Nailed it! Of course, there is one more thing that this command should do. Let's imagine that we've already started a timer on and we want to quickly switch the timer to . We'd expect that the running timer on will stop and a new timer on will begin. project-one project-two project-one project-two Stop One Timer, Start Another We repeat our TDD red-green cycle by first writing a test to represent the missing functionality. test
  .stdout()
  .stub(StartTimerCommand, 'storage', new MemoryStorage({
    activeProject: 'project-one',
    projects: {
      'project-one': {
        activeEntry: 0,
        entries: [
          {
            startTime: new Date(someStartDate),
            endTime: null,
          },
        ],
      },
      'project-two': {
        activeEntry: null,
        entries: [],
      },
    },
  }))
  .stub(Date, 'now', () => someDate)
  .command(['start-timer', 'project-two'])
  .it('should end the running timer from another project before starting a timer on the requested one', async ctx => {
    // Expect that the storage is unchanged
    expect(await StartTimerCommand.storage.load()).to.eql({
      activeProject: 'project-two',
      projects: {
        'project-one': {
          activeEntry: null,
          entries: [
            {
              startTime: new Date(someStartDate),
              endTime: new Date(someDate),
            },
          ],
        },
        'project-two': {
          activeEntry: 0,
          entries: [
            {
              startTime: new Date(someDate),
              endTime: null,
            },
          ],
        },
      },
    })

    expect(ctx.stdout).to.contain('Started a new time entry on "project-two"')
  }) This test requires another timestamp, which we call . We add that near the top of our file: someStartDate start-timer.test.js ...
const someStartDate = 1631936940178
const someDate = 1631943984467 This test is longer than the other tests, but that’s because we needed a very specific initialized within MemoryStorage to represent this test case. You can see that, initially, we have an entry with a and no in . In the assertion, you'll notice that the in is populated, and there is a new active entry in with a and no . db startTime endTime project-one endTime project-one project-two startTime endTime When we run our test suite, we see the following error: 1) start timer
       should end the running timer from another project before starting a timer on the requested one:

      AssertionError: expected { Object (activeProject, projects) } to deeply equal { Object (activeProject, projects) }
      + expected - actual

       {
         "activeProject": "project-two"
         "projects": {
           "project-one": {
      -      "activeEntry": 0
      +      "activeEntry": [null]
             "entries": [
               {
      -          "endTime": [null]
      +          "endTime": [Date: 2021-09-18T05:46:24.467Z]
                 "startTime": [Date: 2021-09-18T03:49:00.178Z]
               }
             ]
           }

      at Context.<anonymous> (test/commands/start-timer.test.js:76:55)
      at async Object.run (node_modules/fancy-test/lib/base.js:44:29)
      at async Context.run (node_modules/fancy-test/lib/base.js:68:25) This error tells us that our CLI correctly created a new entry in , but it didn't first end the timer on . Our application also didn't change the from to in as we expected. project-two project-one activeEntry 0 null project-one Let's fix up the code to solve this issue. Right after we check that the requested project exists, we can add this block of code which will end a running timer on another project and unset the in that project, and it does that all before we create a new timer on the requested project. activeEntry // Check to see if there is a timer running on another project and end it
if (db.activeProject && db.activeProject !== args.projectName) {
	db.projects[db.activeProject].entries[db.projects[db.activeProject].activeEntry].endTime = new Date(Date.now())
	db.projects[db.activeProject].activeEntry = null
} And there we have it! All our tests are passing once again! add project
    ✓ should add a new project (47ms)
    ✓ should return an error if the project already exists (72ms)

  start timer
    ✓ should start a timer for "project-one"
    ✓ should return an error if the user attempts to start a timer on a project that doesn't exist
    ✓ should end the running timer from another project before starting a timer on the requested one Conclusion If you’ve been tracking with our CLI development over Part One and Part Two of this oclif testing series, you’ll see that we’ve covered the and commands. We’ve been demonstrating how easy it is to use TDD to build these commands with and . add-project start-timer oclif @oclif/test Because the and commands are so similar to what we’ve already walked through, we’ll leave their development using TDD as an exercise for the reader. The has those commands implemented as well as the tests used to validate the implementation. end-timer list-projects project repository In summary, we laid out plans for using TDD to build a CLI application using the oclif framework. We spent some time getting to know the package and some of the helpers provided by that library. Specifically, we talked about: @oclif/test Using the method for calling our command and passing it arguments command Methods provided by for stubbing parts of our application, catching errors, mocking stdout and stderr, and asserting on those results @oclif/fancy-test Using TDD to build out a large portion of a CLI using a red-green cycle by writing tests first and then writing the minimal amount of code to get our tests to pass Just like that… you've got another tool in your dev belt—this time, for writing and testing your own CLIs! Also published . here

Build a CLI App with Oclif and Node.js Using Test-Driven Development: Part 2

With the release of 16.3, some new methods have been introduced, and release of React 17 will deprecate some lifecycle method. React lifecycle is one of those newly introduced lifecycle method replacing , which has now become . getDerivedStateFromProps componentWillReceiveProps UNSAFE_componentWillReceiveProps is a static method which is invoked after a component is instantiated as well as when it receives new props. Since it is a static method, you cannot access inside this method neither you can access any other class method. Unlike you cannot set state inside this method, so the only way to update state is returning an object. If you don’t want to update any state, simply return . getDerivedStateFromProps this componentWillReceiveProps null Let’s dive into some code This is how works. componentWillReceiveProps componentWillReceiveProps(nextProps){ (nextProps.someValue!== .props.someValue){ .setState({ : someValue }); .classMethod();
  }
} if this //Perform some operation this someState this View on Github We compare with and if both are different then we perform some operation, and call . nextProps.someValue this.props.someValue setState this.classMethod(); Now let’s have a look how works. getDerivedStateFromProps getDerivedStateFromProps(nextProps, prevState){ (nextProps.someValue!==prevState.someValue){ { : nextProps.someValue};
  } ;
}

componentDidUpdate(prevProps, prevState) { (prevProps.someValue!== .props.someValue){ .setState({ : someValue}); .classMethod();
  }
} static if return someState else return null if this //Perform some operation here this someState this View on Github It receives two params and . As mentioned previously you cannot access inside this method so you’ll have to store the props in the state to compare the with previous props. In above code and are compared, if both are different then an object will be returned to update the state otherwise will be returned indicating state update not required. If state changes then is called where we can perform the desired operations as we did in . nextProps prevState this nextProps nextProps prevState null componentDidUpdate componentWillReceiveProps Let’s make it more clear using an example Let’s say we’re getting some data from firebase and displaying it in the form of stats. Here’s the code for the same. React, {PureComponent} ; DisplayStat { (){ (); .state={ : }
  }
  
  changePath= { .setState({ : });
  }
  
  render(){ ( <DisplayStat path={this.state.path} />
        <div onClick={this.changePath} >Change Path</div>
      </div> import from "react" import from "./displayStat.js" class App extends PureComponent constructor super this path "path-1" => () this path "path-2" return < > div )
  }
} React, {PureComponent} ; { (props){ (); .state={ : firebase.database().ref( .props.path);
    }
  }
  componentDidMount() { .getData( .state.firebaseRef);
  }
  
  componentWillReceiveProps(nextProps){ (nextProps.path!== .props.path){ {firebaseRef}= .state;
      
      firebaseRef.off( ); firebaseRef=firebase.database().ref(nextProps.path); .setState({firebaseRef, :nextProps.path }); .getData(firebaseRef);
    }
  }

  getData= { ref.on( , snapshot => { });
  }
  
  render(){ ( );
  }
} import from "react" class DisplayStat extends PureComponent constructor super this firebaseRef this this this if this let this "value" //Turn off the connection to previous path. this path this ( )=> ref // open connection and listen to firebase path "value" //Perform some operation return //Display Stats < > div </ > div View on Github The above example uses . Initially, the component will listen to firebase on , when a user clicks on the Change Path button the state will change in the file and will be called in the file. The previous connection to firebase path will be closed, and a new will get created. Notice we’re passing firebase reference as parameters to to listen to firebase. componentWillReceiveProps displayStat.js path-1 App.js componentWillReceiveProps displayStat.js getDate() Now let’s do the same thing using . getDerivedStateFromProps React, {PureComponent} ; { (props){ (); .state={ : .props.path, : firebase.database().ref( .props.path);
    }
  }
  componentDidMount() { .getData( .state.firebaseRef);
  }
  
  componentDidUpdate(prevProps, prevState) { (prevState.path !== .state.path) { firebaseRef=firebase.database().ref( .state.path); .setState({firebaseRef}); .getData(firebaseRef);
    }
  } getDerivedStateFromProps(nextProps, prevState){ (nextProps.path!==prevState.path){ firebaseRef=prevState.firebaseRef;
      
      firebaseRef.off( ); { : nextProps.path};
    } ;
  }

  getData= { ref.on( , snapshot => { });
  }
  
  render(){ ( );
  }
} import from "react" class DisplayStat extends PureComponent constructor super this path this firebaseRef this this this if this let this this this static if let "value" //Turn off the connection to previous path. //       We can't do this here as we can't access `this` inside this method. //       firebaseRef=firebase.database().ref(nextProps.path); //       this.setState({firebaseRef, path :nextProps.path }); //       this.getData(firebaseRef); return path else return null ( )=> ref // open connection and listen to firebase path "value" //Perform some operation return //Display Stats < > div </ > div View on Github Notice an object is being returned in the to update the state and no class method is being called. We’re using to check if a path is changed or not and accordingly create a new firebase connection and listen to new path. getDerivedStateFromProps componentDidUpdate Thanks for reading this article. Please hit the Clap button if you like it. Connect with me on . You can also follow me on , , and . LinkedIn Twitter Quora GitHub

Replacing ‘componentWillReceiveProps’ with ‘getDerivedStateFromProps’

Spices and other ingredients of a great curry To use to its full potential you have to embrace its strong functional base. We’re going to explore some crucial and powerful functional constructs: closures, partial application and currying that make JavaScript terse yet understandable. JavaScript programming The basics is a programming paradigm that follows a more mathematical computation model. Let’s go through some basics to make your JavaScript more functional. Functional programming Declarative programming Functional programs tend to be declarative (as opposed to imperative), that’s a case of telling the compiler you want instead of you want it. what how const list = [ 1, 2, 3 ]; // imperative styleconst imperative = list[0]; // declarative styleconst declarative = firstElement(list); In the above code snippet we’re trying to get the first element of , the declarative example says what we want, firstElement can do whatever it likes as long as it returns the first element of the passed parameter. Whereas in the imperative style, we say I want index 0 of explicitly. In JavaScript and at this program size, this doesn’t make a massive difference. list list To build functional programs, we should prefer the declarative style and avoid mutation. Recursion and higher order functions There are no loops in functional programming, just recursion and higher order functions. Mechanisms such as allow for easier recursive function declarations. In ECMAScript 6 (the 2015 edition of the standard JavaScript is based on) we’ve added destructuring to the toolbox, which is a basic pattern matching that works for lists. You can read more about it . pattern matching here _The latest ECMA standard for JavaScript (ECMAScript 6) makes JavaScript more readable by encouraging a more declarative…_hackernoon.com Recursion in JavaScript with ES6, destructuring and rest/spread Higher order functions allow you to traverse iterable collections (Arrays). In JavaScript we have Array#map, Array#filter and Array#reduce. Each of these takes a function as an argument. This is possible because we have first-class functions in JavaScript, which means you can pass them around like any other type of variable :). Lambdas (anonymous functions) In JavaScript we can declare lambas (anonymous functions), which is quite handy considering the API of a lot of libraries expects a function as a parameter. We can just declare the function inline. It might mean a bit of a indentation/bracketing problem but inlining until you can generalise or refactor is actually great. [ 1, 2, 3 ].map(function(el) {return el * 2;}); Closures Here are some >140 character explanations of closures, thanks to for asking and his esteemed followers for answering :). Mateusz Zatorski We can use closures to put state inside an outer function while having access to that state in an inner function. That state is not global but still accessible to child functions. function outerFunction() {const someState = { count: 0 };return {increment: function() {someState.count++;},getCount: function() {return someState.count;}}} const counter = outerFunction(); counter.increment();counter.increment();counter.getCount(); // 2counter.increment();counter.increment();counter.getCount(); // 4 someState; // ReferenceError: someState is not defined The state ( )isn’t global since the last statement returns an error. It is however available to the functions it returned, because they can “see” , it’s in their lexical scope. someState someState Function application Function application is the first “hardcore” functional programming concept we’re going to introduce today. It’s a concept that comes from the mathematics world. A function application, in JavaScript, can look like a function call but doesn’t have to be. function someFunc(arg1, arg2) {return arg1 + arg2;} // function callsomeFunc(1, 2); // 3 // different ways to apply a functionsomeFunc(1, 2); // 3someFunc.apply(this, [ 1, 2 ]); // 3someFunc.call(this, 1, 2); // 3 A function call is an imperative construct whereas a function application belongs to the realm of functional programming and mathematics. In JavaScript you can even use and to define what will be set to during the application. apply call this Partial application Partial application is when you apply some of the required parameters of a function and return a function that takes the rest of the parameters. We’re going to flip the parameters to the function. Instead of taking parameters it’s going to take . This is to illustrate the value of partial application. map (list, fn) (fn, list) function functionalMap(fn, list) {return list.map(fn);} function partialFunctionalMap(fn) {return function(list) {return functionalMap(fn, list);}} // Example 1// Let's apply all the arguments at oncefunctionalMap(x => x * 2, [ 1, 2, 3 ]);functionalMap(x => x * 2, [ 2, 3, 5 ]); // Example 2// Let's apply them one at a timeconst doubleListItems = partialFunctionalMap(x => x * 2);doubleListItems([ 1, 2, 3 ]);doubleListItems([ 2, 3, 5 ]); What the code does in example 1 is less obvious than in example 2. You have to read what the lamba does instead of being told by the variable function name. This is something we can use in places like React event handlers. Now if we went the Object-oriented route, we would use function to the component instance ( ) and to be able to access from inside . We’re trying to leverage functional programming, so no accessing from all the way inside an event handler. We get to store some information that we can get at time (which type is this handler for). When the event triggers, we get the final parameter we need (the event object) and the handler can finish applying. .bind partialHandleClick this this.props.activeType partialHandleClick this .map e Currying A curried function is a function that you apply 1 parameter at a time. function partialFunctionalMap(fn) {return function(list) {return functionalMap(fn, list);}} is curried. In the event handler example isn’t, since the first application provided 2 parameters. partialFunctionalMap partialHandleLinkClick We could rewrite it though. function curriedHandleLinkClick(type){return function(activeType) {return function(e) {const hasKeyboardModifier = e.ctrlKey || e.shiftKey || e.altKey || e.metaKey;updateType(type, activeType, hasKeyboardModifier);};};} And we would use instead of . this.curriedHandleLinkClick(type)(this.props.activeType) this.partialHandleLinkClick(type, this.props.activeType) This isn’t as pretty in JavaScript as in other languages since we’re replacing with . (arg1, arg2, arg3) (arg1)(arg2)(arg3) Currying and partial application Currying is strict: a curried function applied 1 parameter at a time. Partial application is not this strict. always A curried function tends to be partially applied but a partially applied function does have to be curried. not This means we can automate the currying process. In JavaScript we can use libraries to curry functions with multiple arguments. and . They take a function and when applied with a parameter either returns if all required arguments are present or returns a curried function that accepts the rest of the arguments. Lodash has a curry function so does Ramda You can also write your own by accessing the object of the function and using Function#apply. Here are a couple of tutorials that take you through this process. arguments _A technique using partial evaluation_medium.com Currying in JavaScript _I've been thinking a lot lately about functional programming, and I thought it might be kind of fun to walk through the…_kevvv.in Currying in JavaScript Some languages like Haskell are auto-curried. This means that if the function application does not provide the required number of parameters, it will return a function which will accept the rest of the parameters one at a time, just like the and curry functions do. Another cool thing in Haskell is that partial application looks like non-partial application and curried function calls aren’t ugly, since the separator for parameters is a space. Lodash Ramda times a b = a * b times 1 2 double = times 2 Effective Functional JavaScript Recipe Use and abuse closures, partial application and currying. This will enable you to compose your functions and write code that is extremely terse without losing readability. Remember to give this post some 💚 if you liked it. Follow me Hugo Di Francesco or @hugo__df for more JavaScript content :).

Closures, Partial Application and Currying: Effective Functional JavaScript

An Essay Concerning Humane Understanding, Volume I: Book II, Chapter XXVIII.

What is Crypto Adoption Like in Indonesia?

Zuckerberg’s testimony live

Code BEAM SF — San Francisco, CA The BEAM lands in San Francisco this March with Code BEAM SF. Remember ? In 2018 we re-thought a few things and re-launched it as the Code BEAM SF. Learn more about the transition . First two keynotes and are already confirmed! Erlang & Elixir Factory here Kostis Sagonas Richard Cook Marines’ Memorial Club & Hotel, San Francisco Thursday 15 — Friday 16 March 2018 available What you need to know Location: Dates: Ticketed event: Early bird tickets Lonestar ElixirConf 2018 — Austin, TX Elixir comes to Texas this February with . Back for its second year, Lonestar features keynotes from alchemist , core team member , and , core team member. Lonestar ElixirConf Phoenix Framework Chris McCord Nerves Tim Mecklem Aaron Patterson Ruby Norris Conference Center, Austin, TX Thursday 22 — Friday 23 February 2018 available until 3 February What you need to know Location: Dates: Ticketed event: Standard tickets EMPEX LA 2018 — Los Angeles, CA EMPEX is a sophisticated conference series for the Elixir programming language and ecosystem held in LA. This year, EMPEX will present a single track of technical talks, including keynotes from and in a fun space in downtown LA. Emma Cunningham Sarah Gray 1827 South Hope Street, Los Angeles, CA 90015 09:00 PST, Saturday 10 February 2018 get tickets What you need to know Location: Time & Date: Ticketed event: here Lambda Days — Kraków, Poland Lambda Days is a one of a kind experience in the functional programming world. Keynotes and will be joined by and at Lambda Days this February over two days divided into six tracks. Mary Sheeran Philip Wadler Heather Miller José Valim Auditorium Maximum UJ, Kraków Thursday 22 February — Friday 23 February 2018 still available What you need to know Location: Dates: Ticketed event: Regular tickets ElixirDaze 2018 — Denver, CO ElixirDaze is a conference for building the Elixir community with top talks and helpful hacking. Hot off the press, this year’s keynotes will be and Rob Conery Fred Hebert Ophelia’s Electric Soapbox, 1215 20th St, Denver Thursday 1 — Friday 2 March 2018 Only left! What you need to know Location: Dates: Ticketed event: Standard tickets Code BEAM Lite — Milan, Italy meets at Code BEAM Lite in Milan this April. Call for Talks is still open! This event will be bursting with great talk ideas around the themes of tools, BEAM, frameworks, distribution, concurrency and multi-core, curated by the stellar programme committee of , , , and . Already confirmed are , Erlang co-inventor, and , software consultant. Code Sync Coders51 Francesco Cesarini Gabriele Santomaggio Gianluca Randazzo Paolo Laurenti Mike Williams Georgina McFadyen VENINI42, Via Giulio e Corrado Venini, Milan Friday 6 April 2018 available What you need to know Location: Date: Ticketed event: Early bird tickets ElixirConf EU — Warsaw, Poland Following a hugely successful ElixirConf EU 2017 in Barcelona last year, is back on the continent this year, this time in Warsaw! One of the leading European conferences for Elixir, ElixirConf EU’s keynotes include José Valim, Chris McCord, and Evadne Wu. Training is also available. ElixirConf EU Hilton Warsaw Hotel & Convention Centre, Warsaw Monday 16 — Wednesday 18 April 2018 still available What you need to know Location: Dates: Ticketed conference: Early bird tickets EMPEX NYC 2018 — New York City, NY Empire City Elixir Conference 2018, the NYC-based one-day conference for curious programmers is back this May! has already been announced as a keynote speaker. Want to get involved? is still open! Brooklyn Zelenka Call for Papers Subculture, 45 Bleecker St, New York City Saturday 19 May 2018 Keep your eyes peeled for What you need to know Location: Date: Ticketed conference: ticket release Code BEAM STO — Stockholm, Sweden This May marks the inaugural edition of Code BEAM STO conference (formerly known as the ), which now belongs to Code Sync family of tech conferences. Keep your eyes peeled for the first round of speaker announcements! Erlang User Conference Munchenbryggeriet Events & Conferences, Stockholm Thursday 31 May — Friday 1 June 2018 What you need to know Location: Dates: Ticketed conference — Early bird tickets still available Coming up later in 2018 Code Elixir 2018 — London, UK ElixirLDN is back on 16 August under a new name: Code Elixir. Learn more → ElixirConf US 2018 — Bellevue, WA Get excited! ElixirConf returns to Bellevue on 4–7 September! ElixirConf site → Gig City ElixirConf — Chattanooga, TN 26–27 October. Featuring Chris McCord, Dave Thomas, Bruce Tate, and James Edward Gray II. Website coming soon Code Mesh 2018 — London, UK London’s leading alternative programming conference. 8–9 November 2018. Learn more → Want more from the world of functional programming? We’re at Code BEAM SF 2018 in March! Originally published at www.erlang-solutions.com .

Top 10 Erlang & Elixir events of 2018

tl;dr This article shows you how you can use to set up and test against APIs using . OpenShift AWS localstack Example code to run through this using is available . ShutIt here Here’s an asciicast of the process: Introduction In this walkthrough you’re going to set up an system using , and then run localstack in a pod on it. OpenShift minishift is a RedHat-sponsored wrapper around that provides extra functionality more suited to enterprise production deployments of Kubernetes. Many features from have swum upstream to be integrated into Kubernetes (eg role-based access control). OpenShift Kubernetes OpenShift The open source version of OpenShift is called . Origin Localstack Localstack is a project that aims to give you as complete as possible a set of AWS APIs to develop against without incurring any cost. This is great for testing or trying code out before running it ‘for real’ against AWS and potentially wasting time and money. Localstack spins up the following core Cloud APIs on your local machine: at API Gateway http://localhost:4567 at Kinesis http://localhost:4568 at DynamoDB http://localhost:4569 at DynamoDB Streams http://localhost:4570 at Elasticsearch http://localhost:4571 at S3 http://localhost:4572 at Firehose http://localhost:4573 at Lambda http://localhost:4574 at SNS http://localhost:4575 at SQS http://localhost:4576 at Redshift http://localhost:4577 at ES (Elasticsearch Service) http://localhost:4578 at SES http://localhost:4579 at Route53 http://localhost:4580 at CloudFormation http://localhost:4581 at CloudWatch http://localhost:4582 At present it supports running in a Docker container, or natively on a machine. It is built on , which is a mocking framework in turn built on , which is a python AWS SDK. moto boto You can then create distinct endpoints for each set of services, and isolate them from one another. Also, you can worry less about resource usage as the cluster scheduler will take care of that. Running within an OpenShift cluster gives you the capability to run very many of these AWS API environments. However, . it doesn’t run out of the box, so this will guide you through what needs to be done to get it to work Started Minishift? If you don’t have an OpenShift cluster to hand, then you can run up minishift, which gives you a standalone VM with a working OpenShift on it. Installing minishift is documented . You’ll need to install it first and run ‘minishift start’ successfully. here Once you have started minishift, you will need to . set up your shell so that you are able to communicate with the OpenShift server $ eval $(minishift oc-env) Change the default security context constraints Security Context Constraints (scc) are an OpenShift concept that allows more granular control over Docker containers’ powers. They control seLinux contexts, can drop capabilities from the running containers, can determine which user the pod can run as, and so on. To get this running you’re going to change the default ‘restricted’ scc, but you could create a separate scc and apply that to a particular project. To change the ‘restricted’ scc you will need to : become a cluster administrator $ oc login -u system:admin Then you need to edit the restricted scc with: $ oc edit scc restricted You will see the definition of the restricted At this point you’re going to have to do two things: Allow containers to run as any user (in this case ‘root’) Prevent the scc from restricting your capabilities to setuid and setgid 1) Allow RunAsAny The localstack container runs as root by default. For security reasons, OpenShift does not allow containers to run as root by default. Instead it picks a random UID within a very high range, and runs as that. To simplify matters, and allow the localstack container to run as root, : change the lines runAsUser:type: MustRunAsRange to read: runAsUser:type: RunAsAny this allows containers to run as any user. 2) Allow SETUID and SETGID Capabilities When localstack starts up it needs to become another user to start up elasticache. The elasticache service does not start up as the root user. To get round this, localstack su’s the startup command to the localstack user in the container. Because the ‘restricted’ scc explicitly disallows actions that change your user or group id, you need to remove these restrictions. Do this by deleting the lines: - SETUID SETGID Once you have done these two steps, . save the file Make a note of the host If you run: $ minishift console --machine-readable | grep HOST | sed 's/^HOST=$.*$/\1/' you will get the host that the minishift instance is accessible as from your machine. Make a note of this, as you’ll need to substitute it in later. Deploy the pod Deploying the localstack is as easy as running: $ oc new-app localstack/localstack --name="localstack" This takes the localstack/localstack image and creates an OpenShift application around it for you, setting up internal services (based on the exposed ports in the Dockerfile), running the container in a pod, and various other management tasks. Create the routes If you want to access the services from outside, you need to create OpenShift routes, which create an external address to access services within the OpenShift network. For example, to create a route for the sqs service, create a file like this: apiVersion: v1items:- apiVersion: v1kind: Routemetadata:annotations:openshift.io/host.generated: "true"name: sqsselfLink: /oapi/v1/namespaces/test/routes/sqsspec:host: sqs-test.HOST.nip.ioport:targetPort: 4576-tcpto:kind: Servicename: localstackweight: 100wildcardPolicy: Nonestatus:ingress:- conditions:- lastTransitionTime: 2017-07-28T17:49:18Zstatus: "True"type: Admittedhost: sqs-test.HOST.nip.iorouterName: routerwildcardPolicy: Nonekind: Listmetadata: {}resourceVersion: ""selfLink: "" then create the route with: $ oc create -f See above for the list of services and their ports. , you might want to prepend the host name with a unique name for the instance, eg If you have multiple localstacks running on your OpenShift cluster host: localstackenv1-sqs-test.HOST.nip.io .Look upon your work Run an ‘oc get all’ to see what you have created within your OpenShift project: $ oc get allNAME DOCKER REPO TAGS UPDATEDis/localstack 172.30.1.1:5000/myproject/localstack latest 15 hours ago NAME REVISION DESIRED CURRENT TRIGGERED BYdc/localstack 1 1 1 config,image(localstack:latest) NAME DESIRED CURRENT READY AGErc/localstack-1 1 1 1 15h NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARDroutes/apigateway apigateway-test.192.168.64.2.nip.io localstack 4567-tcp Noneroutes/cloudformation cloudformation-test.192.168.64.2.nip.io localstack 4581-tcp Noneroutes/cloudwatch cloudwatch-test.192.168.64.2.nip.io localstack 4582-tcp Noneroutes/dynamodb dynamodb-test.192.168.64.2.nip.io localstack 4569-tcp Noneroutes/dynamodbstreams dynamodbstreams-test.192.168.64.2.nip.io localstack 4570-tcp Noneroutes/es es-test.192.168.64.2.nip.io localstack 4578-tcp Noneroutes/firehose firehose-test.192.168.64.2.nip.io localstack 4573-tcp Noneroutes/kinesis kinesis-test.192.168.64.2.nip.io localstack 4568-tcp Noneroutes/lambda lambda-test.192.168.64.2.nip.io localstack 4574-tcp Noneroutes/redshift redshift-test.192.168.64.2.nip.io localstack 4577-tcp Noneroutes/route53 route53-test.192.168.64.2.nip.io localstack 4580-tcp Noneroutes/s3 s3-test.192.168.64.2.nip.io localstack 4572-tcp Noneroutes/ses ses-test.192.168.64.2.nip.io localstack 4579-tcp Noneroutes/sns sns-test.192.168.64.2.nip.io localstack 4575-tcp Noneroutes/sqs sqs-test.192.168.64.2.nip.io localstack 4576-tcp Noneroutes/web web-test.192.168.64.2.nip.io localstack 8080-tcp None NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGEsvc/localstack 172.30.187.65  4567/TCP,4568/TCP,4569/TCP,4570/TCP,4571/TCP,4572/TCP,4573/TCP,4574/TCP,4575/TCP,4576/TCP,4577/TCP,4578/TCP,4579/TCP,4580/TCP,4581/TCP,4582/TCP,8080/TCP 15h NAME READY STATUS RESTARTS AGEpo/localstack-1-hnvpw 1/1 Running 0 15h Each route created is now accessible as an AWS service ready to test your code. Access the services Can now hit the services from your host, like this: $ aws --endpoint-url=http://kinesis-test.192.168.64.2.nip.io kinesis list-streams{"StreamNames": []} For example, to create a kinesis stream: $ aws --endpoint-url=http://kinesis-test.192.168.64.2.nip.io kinesis create-stream --stream-name teststream --shard-count 2$ aws --endpoint-url=http://kinesis-test.192.168.64.2.nip.io kinesis list-streams{"StreamNames": ["teststream"]} This is an extract from my book This is a work in progress from the second edition of Docker in Practice Get 39% off with the code: 39miell

Run Your Own AWS APIs on OpenShift

Anthropic, the company behind the Claude series of models, has released Claude 3.5 Sonnet. It comes at a time when we all have accepted GPT-4o to be the default best model for the majority of tasks like reasoning, summarization, etc. Anthropic makes the bold claim that their model sets the new “industry standard” for intelligence. Additionally, it's available for free on claude.ai if you wish to give it a spin. So, we got excited and wanted to test the model and compare it against GPT-4o. This article starts with an overview of the features released with Claude 3.5 and tests it against GPT-4o on code generation, as well as logical and mathematical reasoning tasks. Main Features The model comes with three main features or novelties that make them claim that it beats GPT-4o in most tasks. Improved vision tasks. The model boasts state-of-the-art performance on 4 out of 5 vision tasks as per their published results below. 2x speed. Compared to GPT-4o or its own predecessors like Claude Opus, Claude Sonnet boasts of 2X generation speed.
Artifacts — a new UI for tasks like code generation and animation. Let's dive deeper into the features and compare them with the long-reigning King of LLMs, GPT-4o. Getting Started To get started we have to be logged into the claude.ai website and enable the artifacts feature. As it's an experimental feature, we need to enable it. We have to go under feature preview and enable Artifacts from there as shown below. Once enabled, the model will show a dedicated window on the side for tasks that need them like coding or animations. Vision Tasks — Visual Reasoning To test the improved visual reasoning ability, we upload the below two plots to the Claude Sonnet model and asked the question, “What can you make out from this data?”. Plots as images for testing visual reasoning The response from Claude Sonnet was astounding. It precisely summarised deep learning progress saying, “This data illustrates rapid progress in deep learning architectures and model scaling, showing a trend towards larger, more powerful models”. We got a similar response from GPT-4o as well. So, to get a better understanding of which is better, we started to compare both the models systematically in four tasks — coding, coding with UI, logical reasoning, and Math reasoning. Versus GPT-4o — Which is best? Now that we have seen an overview let's dive deep and take the model for a ride. Let's test for code generation, logical reasoning, and mathematical reasoning. Code Generation For code generation, I am going to ask both models to generate code for playing the well-known Sudoku game. I prompted both the models with the exact prompt, “write python code to play the sudoku game.” With this prompt, both Claude 3.5 and GPT-4o generate code with which we can interact only from the command prompt. This is expected as we did not specify how to generate UI code. Some initial observations: Both models churn out bug-free code.
Claude generates code with the feature to choose the difficulty level. But GPT-4o doesn’t!
With the speed of code generation, Claude beats GPT-4o without a doubt
GPT-4o tends to generate code with unnecessary packages Code Generation with UI As interacting with the command prompt is not for everyone, I wanted the models to generate code with UI. For this, I modified the prompt to, “write code to play a sudoku game”. This time, I removed “python” from the prompt as I felt that it would prompt it to produce just the backend code. As expected, Claude 3.5 did produce a functional UI this time as below. Though the UI was not completely robust and appealing, it was functional. But GPT-4o, unfortunately, did not produce a similar UI. It still generated code with an interactive command prompt. Puzzle 1 — Logical Reasoning For the first puzzle, I asked the below question: Jane went to visit Jill. Jill is Jane’s only husband’s mother-in-law’s only husband’s only daughter’s only daughter. what relation is Jane to Jill? Both the models came up with a sequence of reasoning steps and answered the question correctly. So it has to be a tie between Claude 3.5 and GPT-4o in this case. Puzzle 2 — Logical Reasoning For the second puzzle, I asked the below question: Which of the words is least like the others. The difference has nothing to do with vowels, consonants or syllables. MORE, PAIRS, ETCHERS, ZIPPER\ For this, both the models came up with different logical reasoning steps to come up with different answers. Claude reasoned that zipper is the only word that can function as both a noun and a verb. But others are either just nouns or adjectives. So, it identified ZIPPER as the answer. GPT-4o, on the other hand, identified MORE reasoning that it's not a concrete object or a specific type of person. All this indicates that we need to make the prompt more specific thereby leading to a tie in this case. Puzzle 3 — Math reasoning Let's move on to a well-known visual reasoning puzzle that can be calculated by a formula. So I gave the below figure along with the below prompt as input to both models. The below 3 circles all have blue dots on their circumference which are connected by straight lines. The first circle has two blue dots separating it into two regions. Given a circle with 7 dots place anywhere on its circumference, what is the maximum number of regions the circle can be divided into? In this case, GPT-4o came up with the bang-on right answer of 57. But Claude 3.5 came up with the answer of 64 which is not quite correct. Both models gave logical reasoning steps as to why they arrived at the answer. The formatting of the math formulas in GPT-4o is preferable to that of Claude 3.5. Our Verdict Based on our tests, we conclude that the winner with code generation tasks, be it pure-backed code or GUI code, is Claude 3.5 sonnet. It's a close tie with logical reasoning tasks. But when it comes to mathematical reasoning tasks, GPT-4o still leads the way and Claude is yet to catch up. In terms of generation speed, Claude is no doubt the winner as it churns out text or code much faster than GPT-4o. Check out our video if you wish to compare the speed of text generation in real time. Shout Out If you liked this article, why not follow me on Twitter where I share research updates from top AI labs every single day of the week? Also please subscribe to my YouTube channel where I explain AI concepts and papers visually. Anthropic, the company behind the Claude series of models, has released Claude 3.5 Sonnet. It comes at a time when we all have accepted GPT-4o to be the default best model for the majority of tasks like reasoning, summarization, etc. Anthropic makes the bold claim that their model sets the new “industry standard” for intelligence. Additionally, it's available for free on claude.ai if you wish to give it a spin. So, we got excited and wanted to test the model and compare it against GPT-4o. This article starts with an overview of the features released with Claude 3.5 and tests it against GPT-4o on code generation, as well as logical and mathematical reasoning tasks. Main Features The model comes with three main features or novelties that make them claim that it beats GPT-4o in most tasks. Improved vision tasks. The model boasts state-of-the-art performance on 4 out of 5 vision tasks as per their published results below. Improved vision tasks. The model boasts state-of-the-art performance on 4 out of 5 vision tasks as per their published results below. Improved vision tasks. 2x speed. Compared to GPT-4o or its own predecessors like Claude Opus, Claude Sonnet boasts of 2X generation speed. Artifacts — a new UI for tasks like code generation and animation. 2x speed. Compared to GPT-4o or its own predecessors like Claude Opus, Claude Sonnet boasts of 2X generation speed. 2x speed. Artifacts — a new UI for tasks like code generation and animation. Artifacts Let's dive deeper into the features and compare them with the long-reigning King of LLMs, GPT-4o. Getting Started To get started we have to be logged into the claude.ai website and enable the artifacts feature. As it's an experimental feature, we need to enable it. We have to go under feature preview and enable Artifacts from there as shown below. Once enabled, the model will show a dedicated window on the side for tasks that need them like coding or animations. Vision Tasks — Visual Reasoning To test the improved visual reasoning ability, we upload the below two plots to the Claude Sonnet model and asked the question, “What can you make out from this data?”. Plots as images for testing visual reasoning The response from Claude Sonnet was astounding. It precisely summarised deep learning progress saying, “This data illustrates rapid progress in deep learning architectures and model scaling, showing a trend towards larger, more powerful models”. We got a similar response from GPT-4o as well. So, to get a better understanding of which is better, we started to compare both the models systematically in four tasks — coding, coding with UI, logical reasoning, and Math reasoning. Versus GPT-4o — Which is best? Now that we have seen an overview let's dive deep and take the model for a ride. Let's test for code generation, logical reasoning, and mathematical reasoning. Code Generation For code generation, I am going to ask both models to generate code for playing the well-known Sudoku game. I prompted both the models with the exact prompt, “write python code to play the sudoku game.” With this prompt, both Claude 3.5 and GPT-4o generate code with which we can interact only from the command prompt. This is expected as we did not specify how to generate UI code. Some initial observations: Both models churn out bug-free code. Claude generates code with the feature to choose the difficulty level. But GPT-4o doesn’t! With the speed of code generation, Claude beats GPT-4o without a doubt GPT-4o tends to generate code with unnecessary packages Both models churn out bug-free code. Claude generates code with the feature to choose the difficulty level. But GPT-4o doesn’t! With the speed of code generation, Claude beats GPT-4o without a doubt GPT-4o tends to generate code with unnecessary packages Code Generation with UI As interacting with the command prompt is not for everyone, I wanted the models to generate code with UI. For this, I modified the prompt to, “write code to play a sudoku game”. This time, I removed “python” from the prompt as I felt that it would prompt it to produce just the backend code. As expected, Claude 3.5 did produce a functional UI this time as below. Though the UI was not completely robust and appealing, it was functional. But GPT-4o, unfortunately, did not produce a similar UI. It still generated code with an interactive command prompt. Puzzle 1 — Logical Reasoning For the first puzzle, I asked the below question: Jane went to visit Jill. Jill is Jane’s only husband’s mother-in-law’s only husband’s only daughter’s only daughter. what relation is Jane to Jill? Jane went to visit Jill. Jill is Jane’s only husband’s mother-in-law’s only husband’s only daughter’s only daughter. what relation is Jane to Jill? Jane went to visit Jill. Jill is Jane’s only husband’s mother-in-law’s only husband’s only daughter’s only daughter. what relation is Jane to Jill? Both the models came up with a sequence of reasoning steps and answered the question correctly. So it has to be a tie between Claude 3.5 and GPT-4o in this case. Puzzle 2 — Logical Reasoning For the second puzzle, I asked the below question: Which of the words is least like the others. The difference has nothing to do with vowels, consonants or syllables. MORE, PAIRS, ETCHERS, ZIPPER\ Which of the words is least like the others. The difference has nothing to do with vowels, consonants or syllables. MORE, PAIRS, ETCHERS, ZIPPER\ Which of the words is least like the others. The difference has nothing to do with vowels, consonants or syllables. MORE, PAIRS, ETCHERS, ZIPPER\ For this, both the models came up with different logical reasoning steps to come up with different answers. Claude reasoned that zipper is the only word that can function as both a noun and a verb. But others are either just nouns or adjectives. So, it identified ZIPPER as the answer. GPT-4o, on the other hand, identified MORE reasoning that it's not a concrete object or a specific type of person. All this indicates that we need to make the prompt more specific thereby leading to a tie in this case. Puzzle 3 — Math reasoning Let's move on to a well-known visual reasoning puzzle that can be calculated by a formula. So I gave the below figure along with the below prompt as input to both models. The below 3 circles all have blue dots on their circumference which are connected by straight lines. The first circle has two blue dots separating it into two regions. Given a circle with 7 dots place anywhere on its circumference, what is the maximum number of regions the circle can be divided into? The below 3 circles all have blue dots on their circumference which are connected by straight lines. The first circle has two blue dots separating it into two regions. Given a circle with 7 dots place anywhere on its circumference, what is the maximum number of regions the circle can be divided into? The below 3 circles all have blue dots on their circumference which are connected by straight lines. The first circle has two blue dots separating it into two regions. Given a circle with 7 dots place anywhere on its circumference, what is the maximum number of regions the circle can be divided into? In this case, GPT-4o came up with the bang-on right answer of 57. But Claude 3.5 came up with the answer of 64 which is not quite correct. Both models gave logical reasoning steps as to why they arrived at the answer. The formatting of the math formulas in GPT-4o is preferable to that of Claude 3.5. Our Verdict Based on our tests, we conclude that the winner with code generation tasks, be it pure-backed code or GUI code, is Claude 3.5 sonnet. It's a close tie with logical reasoning tasks. But when it comes to mathematical reasoning tasks, GPT-4o still leads the way and Claude is yet to catch up. In terms of generation speed, Claude is no doubt the winner as it churns out text or code much faster than GPT-4o. Check out our video if you wish to compare the speed of text generation in real time. video video Shout Out If you liked this article, why not follow me on Twitter where I share research updates from top AI labs every single day of the week? If you liked this article, why not follow me on Twitter where I share research updates from top AI labs every single day of the week? Twitter Twitter Also please subscribe to my YouTube channel where I explain AI concepts and papers visually. Also please subscribe to my YouTube channel where I explain AI concepts and papers visually. YouTube channel YouTube channel

Claude 3.5 Sonnet vs GPT-4o — An honest review

ক্লড 3.5 সনেট বনাম GPT-4o — একটি সৎ পর্যালোচনা

Claude 3.5 Sonnet vs. GPT-4o – Ein ehrlicher Test

Claude 3.5 Sonnet vs GPT-4o: una revisión honesta

Claude 3.5 Sonnet vs GPT-4o — Une critique honnête

क्लाउड 3.5 सॉनेट बनाम GPT-4o — एक ईमानदार समीक्षा

Claude 3.5 Sonnet vs GPT-4o — 正直なレビュー

Claude 3.5 Sonnet 대 GPT-4o — 정직한 리뷰

Claude 3.5 Sonnet vs GPT-4o – Uma revisão honesta

Claude 3.5 Sonnet против GPT-4o — Честный обзор

Claude 3.5 Sonnet vs GPT-4o — Dürüst bir inceleme

Claude 3.5 Sonnet vs GPT-4o - Đánh giá trung thực

Claude 3.5 Sonnet 与 GPT-4o 的对比——诚实的评价

In this article, email signature generator shares its experience of launching on the AppSumo platform. It won't be just another success story; we'll also explain how we inadvertently reduced our potential sales by 30%. MySignature What Is an AppSumo? AppSumo is a platform that provides exclusive deals on software tools and , connecting entrepreneurs and businesses with discounted lifetime deals. digital products A lifetime deal entails the customer paying only once and having access to the product throughout its entire lifecycle. In essence, you possess the product, and AppSumo brings in the customers. Offering an attractive price for your product can attract a substantial number of potential customers, generating significant revenue. In addition to selling your product at a substantial discount (e.g., 60-80%), you also share approximately 70% of the revenue with AppSumo (resulting in about 30% for you). The final proportion of revenue sharing can be changed and is discussible. For some, it sounds totally insane. But here are a few benefits that can sweeten the bitter pill. Our Results From Our AppSumo Launch Our AppSumo launch was divided into two parts: the first phase lasted for 6 weeks, and the second phase occurred after 6 months for 1 week. We achieved the following results: Ranked as the #3 product of the week 2,622 sales/customers $138,000 in total sales $46,026 as our income (MySignature's share) 93 reviews with a 4.08 rating More than 1280 tickets 240+ questions on the AppSumo platform In general, we are satisfied with the results, but we acknowledge making one mistake that we believe may have reduced our potential income by about 30%. We will elaborate on this mistake and others below. What Do You Gain When You Run an AppSumo Deal? Huge Market AppSumo boasts a sizable user base of approximately 800,000 users and nearly eagerly seeking early access to software and attractive deals. Most of AppSumo's audience is from the US and other English-speaking countries. 3 million visitors This presents an opportunity to acquire more than 2000 customers, which sounds great. However, it's important to note that AppSumo offers more than just monetary benefits. Feedback Running an AppSumo deal guarantees an influx of feedback. Users will have numerous questions about your product, business, and your long-term plans. Free QAs After buying your product, a lot of users with different mindsets from various countries and platforms will test your service and ask questions, bringing huge benefits to the table if you still developing your go-to-market strategy. Be ready to handle a lot of bugs and suggestions tickets. We will discuss it further later. SEO / PR Participating in an AppSumo deal can yield SEO benefits, including external links to your website from coupon sites (best deals) and potential media coverage if your product captures interest. Army of 300 Spartans AppSumo users, after purchasing your deal, are encouraged to leave reviews about your service and participate in surveys in exchange for additional benefits, such as extra credits for their lifetime deals. These users are valuable assets to your business; they tend to be more active than your regular buying customers and can play long-term relationships. Future Upgrades and Upsells As mentioned above, AppSumo users can play a long-term role in your business. You can attempt to sell additional offers 6-9 months after concluding the AppSumo launch to customers. This might involve upgrading their lifetime deals with more credits. However, be prepared to offer competitive prices. Additionally, it's also fair to highlight some disadvantages and negative aspects of running the AppSumo deal. Impact on Branding Traffic Sales When running an AppSumo deal, it typically spans a few weeks, including an additional "Last Call" period after the main launch. In the case of MySignature, our AppSumo deal page ranked as the #2 result in Google search results for our brand keywords. Given that branding traffic is highly convertible into sales, we observed a slight decrease in the conversion rate for branding traffic during the AppSumo deal. Our hypothesis is that some customers who Google "MySignature" and are familiar with AppSumo may choose to buy the lifetime deal on AppSumo rather than on our site. Although not a significant problem, it's essential to be mindful of this, especially if you have substantial traffic from brand keywords. In our case, we ran Google ads to secure an additional link in Google results and mitigate potential negative consequences. Need for Team Mental Health Recovery While it may sound like a joke, AppSumo users are not as willing to wait for bug fixing and customer support answers as your regular users. Your entire team, especially support, will be under immense pressure during the initial and final days of the AppSumo launch. Despite making pre-launch preparations such as creating an FAQ and knowledge base, and reinforcing your support team with new members, it usually isn't enough to strike the right balance between customer satisfaction and team intensity. Be prepared to receive some negative reviews for perceived "long" support answers. And, of course, consider organizing a celebration after the launch to help your burned-out team recover. :) How to Start a Launch on AppSumo You can run your product on AppSumo either independently or when AppSumo invites you and assists with the preparation (Appsumo select). The latter is our situation. After signing the agreement with AppSumo, your preparation should commence. The AppSumo team will offer recommendations and outline a roadmap for you: Record demo videos Create demo videos showcasing your product. Some parts of these videos will be used in the promotional material. Provide key messages Prepare key messages about your product, your future plans, detailed descriptions, and notable features. Technical integrations Collaborate with the technical team to implement necessary integrations with the AppSumo API. This includes setting up integrations with AppSumo API for selling, activating, and processing refunds for your product. In addition to these steps recommended by AppSumo, we'll share our experiences on what else you should do for a successful launch. Preparation Support It is crucial to prepare FAQs and a Knowledge Base in advance; you will link these resources to the AppSumo deal page. After the launch, users will often ask similar questions. To enhance your support team's efficiency, consider collecting answers to frequently asked questions about and creating templates. This approach saves time and avoids crafting responses from scratch for similar inquiries. email signatures Roadmap The next step is to prepare the roadmap for your product, as AppSumo users often inquire about future plans. Anticipate that users will request new features, so create a special form for feature requests. We used Google Forms for this purpose. Additionally, allocate time slots in your roadmaps for the most requested features. For example, the CNAME feature was highly popular among our AppSumo users, and we incorporated it into our roadmap, contributing to additional sales. Promotion Plan AppSumo will handle all marketing aspects, running ads on platforms like Instagram, Facebook, and others. They will also create a promotional video for YouTube. For highly popular products, AppSumo might include your product in their weekly email digest (1.5M+ email distribution list), providing 2-3 spikes in sales during the launch period. In general, you may not need to exert extra effort to sell your product. However, we experimented with some additional marketing strategies to promote our deal on AppSumo. Social Media Groups We promoted our deal on Facebook and Reddit groups. To do this, we searched for AppSumo deal, LTD, and other relevant keywords to identify the most related groups. It's crucial to note that you need to do this before the launch because some groups are closed, requiring an invitation and approval. Also, check if everyone can publish posts or if you need to contact the admin for approval. In return, they may ask you to activate one of your Tiers on AppSumo for free. Facebook groups serve as an excellent additional marketing channel for your deal, leading to dozens of extra sales. Be prepared to respond to questions in the comments section of your post. Other Marketing Ideas Find special YouTube channels that create deal/product video reviews or conduct interviews. Discover websites that feature the best monthly deals. For an extra fee, you can attempt to feature your deal in some prominent spots. Important Note: AppSumo does not recommend and, in some cases, forbids certain noise marketing promotions — they manage all promotions on their side. This is why we refrain from running giveaways with certain Facebook groups. The Key Element of the Successful AppSumo Launch Here is the key success element that we learned during the AppSumo launch. Reviews are crucial! The quantity and rating play a significant role in your deal, visibly in special sections on AppSumo, but they also play a decisive role in the decision-making process of whether to buy your deal or not. How Do We Encourage Reviews? First of all, you should set up an automatic email sequence for AppSumo users to leave reviews; you can offer some extra credits as a thank-you. Your support team should also ask customers to leave a review, especially if the customer is satisfied. AppSumo users always look for social proof of products on resources they trust. So be sure that you also have a good rating on G2 and TrustPilot. Work With Negative Reviews A negative review is not the final verdict. You can ask the user to change their review if you solve his/her problem and send a special form. The AppSumo team will provide you with the link to such a form. Another important aspect is learning how to be successful; you can learn from the mistakes we made and how to avoid losing 20-30% of sales. One Mistake - 30% Less Sales Okay, we are uncertain about the number of sales we missed due to the following mistakes. Considering the amount of refunds, we anticipate that it might exceed 20-30% of our income. Our mistake was the lack of clear identification for one of our AppSumo Tiers: Tier 1, Tier 2, and Tier 3. The issue arose because we employed different approaches to create our services. Tiers 1 and 2 grant users access to the MySignature email signature generator, enabling them to create and manage signatures for themselves or their team and utilize the feature. Gmail tracker On the other hand, Tier 3 (Agency Hub)  is designed for resellers/agencies primarily seeking a solution for their clients to create and manage email signatures without the tracking feature. Consequently, features like Gmail tracker were not technically available in Tier 3, unlike Tiers 1 and 2, which serve other business purposes and include Gmail tracker options. This confusion led to AppSumo questioning why Tier 3, expected to be the most powerful plan encompassing all features from Tiers 1 and 2, lacked email tracking. This confusion resulted in numerous negative reviews, inquiries to the support team, and comments in Facebook groups related to the AppSumo community. Another oversight was our failure to provide clear plan descriptions outlining the differences between the plans. Also, users who bought Tier 3 and expected all features from Tier 1 and 2 were disappointed when they didn't find the Gmail tracking feature. We completely understand users' frustrations and have provided all the necessary explanations. To be frank, we didn't have full access to the deal page descriptions on AppSumo; that's why it took some time to contact AppSumo's content team and request changes in the text descriptions of the plan. So, summing up our mistake, we would advise: Ensure that your plans are described absolutely clearly for users. Make the positioning of plan features logical and understandable for users. The best approach is when all plans include all features, and differences are in credit amounts. Don't expect users to read all the text. Surprise, surprise! Takeaway The main takeaway that we want to emphasize is to ensure that you provide clear deal descriptions. Encourage reviews — they are fuel for selling your deals. And lastly, be ready to manage processes on the fly — bug fixing and adding new FAQs. Don't forget to take a break after the AppSumo deal to reach new highs! Was it Worth it? Absolutely! The entire experience was undeniably valuable. Collaborating with AppSumo enabled us to gain traction in a way that would have been extremely challenging through other means. Additionally, it facilitated valuable product feedback, significantly accelerating the development process.

Stories, News & Mentions about SONESTA

Sonesta’s Stories on HackerNoon

Sonesta's News & Mentions