Get the most recent info and news about Sonesta Hotels on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Sonesta is now the 8th largest hotel company in the world, with 16 brands that consist of 1200 hotels, 100K+ rooms, across three continents and include: The Royal Sonesta, Sonesta Hotels & Resorts, Sonesta Select, Sonesta ES Suites, Sonesta Simply Suites, Sonesta Posadas Del Inca (Peru), Sonesta Cruise Collection (Nile River), and the Red Lion family of brands. With the growth of the company, we have also expanded our award-winning guest loyalty program – Sonesta Travel Pass. Offering guests a variety of travel experiences, free nights, value added perks, points that can be redeemed at any of the Sonesta branded hotels (excluding Egypt). Sprung from the classic hoteliers of the mid-20th century, Sonesta is a collection of hotels, resorts, suites and cruises enjoys a rich history celebrating over 80 years in hospitality. When savvy travelers stay in one of our locations throughout the world, they are treated to a genuine experience, reflective of the culture and personality of the destination. Guests are always delighted to find that we have let the outside culture in! As one of the original hoteliers in the United States, Sonesta has a solid understanding of what drives the passion for travel – service, beautiful surroundings and an unmatched destination experience delivered with style. It’s our employees who deliver on this promise with integrity and passion, ensuring our future will be as strong as our past. Discover what you have been missing at Sonesta. Join us. We can’t wait to meet you.

Sonesta Hotels

sonesta

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

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

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

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.

Our AppSumo Launch: An Honest Review and Explaining How We Lost 30% of Our Potential Revenue

আমাদের অ্যাপসুমো লঞ্চ: একটি সৎ পর্যালোচনা এবং ব্যাখ্যা করা হচ্ছে কীভাবে আমরা আমাদের সম্ভাব্য আয়ের 30% হারিয়েছি

Unser AppSumo-Start: Ein ehrlicher Rückblick und eine Erklärung, wie wir 30 % unseres potenziellen Umsatzes verloren haben

Nuestro lanzamiento de AppSumo: una revisión honesta y una explicación de cómo perdimos el 30% de nuestros ingresos potenciales

Notre lancement AppSumo : un examen honnête et expliquant comment nous avons perdu 30 % de nos revenus potentiels

हमारा ऐपसुमो लॉन्च: एक ईमानदार समीक्षा और यह बताना कि कैसे हमने अपने संभावित राजस्व का 30% खो दिया

AppSumo の立ち上げ: 正直なレビューと潜在的な収益の 30% をどのように失ったかを説明する

AppSumo 출시: 솔직한 리뷰 및 잠재 수익의 30% 손실 이유 설명

Nosso lançamento do AppSumo: uma análise honesta e uma explicação de como perdemos 30% de nossa receita potencial

Запуск нашего AppSumo: честный обзор и объяснение того, как мы потеряли 30% потенциального дохода

AppSumo Lansmanımız: Dürüst Bir İnceleme ve Potansiyel Gelirimizin %30'unu Nasıl Kaybettiğimizi Açıklamak

Ra mắt AppSumo của chúng tôi: Đánh giá trung thực và giải thích lý do chúng tôi mất 30% doanh thu tiềm năng

我们的 AppSumo 发布：诚实的回顾并解释我们如何损失了 30% 的潜在收入

So Google recently just dropped a list of free Intro to Generative AI courses and the biggest question is - are they worth the hype? I guess that’s what I’m here for. After completing Google’s Introduction to Generative AI learning path ( ), here are my two cents. check it out here Table of Contents Course Breakdown Target Audience Learning Goals Content Analysis Summary/Cheatsheets Final Verdict (Is it Worth It?) Additional Resources Google’s Generative AI Learning Path Course Breakdown Target Audience Google’s courses are catered to students without prior technical knowledge of the topic, or as explained on their , the path is designed for the non-technical, tech-adjacent audience with roles like sales, HR, marketing, and operations. On that note, this means that the course doesn’t provide in-depth but does give a great introduction to fundamental concepts in generative AI. blog how-to’s Learning Goals The idea is to properly answer the question “But what actually is Generative AI?”. The emphasis of the course is on Generative AI, Large Language Models, and ethics in AI. Through the course, you’ll also be able to learn about the and Google’s role in incorporating responsible AI practices, which includes a mix of case studies, lecture-style videos, and quizzes. AI services provided by Google Content Analysis So let’s decipher the material in the learning path: Introduction to Generative AI - course Introduction to Large Language Models - course Introduction to Responsible AI - course Generative AI Fundamentals - course with skill badge Responsible AI: Applying AI Principles with Google Cloud - course Understand this, the Generative AI Fundamentals course is basically a compilation of the first three courses (Intro to Gen AI, Intro to LLM, and Intro to Responsible AI), but with the addition of a quiz. And here’s the deal - if you were to complete the courses prior to the skill badge course, you wouldn’t need to redo them. My guess on why the learning path is formatted that way is to ensure that you’ll actually go through the course materials rather than just clicking ‘next’ when attempting the Generative AI Fundamentals skill badge. Picking out the content from the courses, here are some cheatsheets I developed: Summary + Cheatsheets Generative AI Starting with “What is Artificial Intelligence?”, it’s a field in Computer Science that mimics human cognition to perform complex tasks and learn from them. Within AI, there exists the subfield of Machine Learning which uses algorithms trained on data to produce adaptable models that can perform various complex tasks. Within ML, there exist different types including supervised learning, unsupervised learning, reinforcement learning, and deep learning. Deep learning uses artificial neural networks, allowing them to make more complex patterns whereby its neural networks use supervised learning, unsupervised learning, and semi-supervised learning to achieve its goal. There are two types of deep learning models, namely discriminative and generative. Generative AI is a type of Artificial Intelligence technology that can produce various types of content, including text, imagery, audio, and synthetic data. In short, GenAI is a type of AI that creates new content based on what it has learned from existing content. It uses a learning process called training which results in the creation of a statistical model, in turn, is used to predict what an expected response may be when given a prompt. Large Language Models Large language models are deemed large because of two factors - being trained on a large training dataset with a large number of parameters. Often called hyperparameters, parameters are essentially the memories and the knowledge that the machine learned, and are used to define the skill of the model to solve problems. LLMs are also general purpose as they strive to solve common problems using human languages. There are two kinds of LLMs, namely pre-trained and fine-tuned whereby pre-trained models can do “everything” but have their practical limitations whereas fine-tuned models fit a specific niche or aim to solve a specific problem. It’s important to note that fine-tuning tends to be expensive, thus more efficient methods exist such as Parameter-Efficient Tuning Methods (PETM) like Prompt Tuning. To understand prompts, they are essentially inputs that are given to an LLM to elicit a specific response. The usual misconception is between prompt design and prompt engineering. To break it down, prompt design is tailored to the specific task that the system is being asked to perform whereas prompt engineering is designed to improve the model’s performance by using domain-specific knowledge, providing examples of a desired output, and using keywords that are known to be effective for this specific system. AI/ML Services by Google Vertex AI offers a model garden for foundation models. Consider the use case whereby the user intends to use a model to predict customer satisfaction, they can opt-in to use the Classification Task type Sentiment Analysis Task Model. Integrating the PaLM API with MakerSuite simplifies the Generative Development Cycle. MakerSuite includes a bunch of resources such as a model training tool to train models on the user’s data using different algorithms, a model deployment tool to allow users to deploy their models to production, and a model monitoring tool to monitor the model’s performance in production. The GenAI Studio allows users to quickly explore and customize GenAI models with resources such as a library of pre-trained models, tools for fine-tuning models, tools for deploying models to production, and a community forum for more support. The GenAI App Builder provides users with a drag-and-drop interface, a visual editor to edit app content, a built-in search engine, and a conversational AI engine. is a conversational AI tool that essentially is an LLM similar to ChatGPT. Bard Free AI Courses by Google - Are They Worth It? Yes, in the simplest terms, they are. If you knew me, you’d know that I always stand by . taking advantage of new learning opportunities However, it's important to note that the course is not perfect. There can be some overlap between certain topics, and it only focuses on Google's contributions to the AI industry. Additionally, the quizzes may not be challenging enough, especially considering the fact that each module usually consists of only 3-5 questions per quiz. However, it's worth considering that the course is completely free and allows you to showcase your achievements on social media platforms and your resume. Furthermore, the course is concise and straightforward, so it won't consume too much of your time. Take it from me, I was able to finish the path in less than a day 👀 How to Continue Your Generative AI Learning Journey Beyond Google Courses I’d like to think that our learning journey should never depend on only one source, here are some other courses you can take a look at: Generative AI with Large Language Models by DeepLearning.AI Introduction to Generative AI by Microsoft Generative AI Foundations on AWS Technical Deep Dive Series by AWS Do You Speak Vector? Understanding the Language of LLMs and Generative AI by Datastax A Beginner’s Guide to Using Large Language Models (LLMs) with the PaLM API Others: Hugging Face Tensorflow LangChain

Stories, News & Mentions about SONESTA

Sonesta’s Stories on HackerNoon

Sonesta's News & Mentions