Nova Scotia is introducing a mobile app aimed at giving people easier access to some health services through their phones. Developed at a cost of $10 million, officials say YourHealthNS is a one-stop shop to book services,

New app aimed at helping Nova Scotians access health services and information

The way AI systems work means that we can’t easily delete what they have learned. Now, researchers are seeking ways to remove sensitive information without having to retrain them from scratch

With privacy concerns rising, can we teach AI chatbots to forget?

The Parliamentary Standing Committee on Communications and Information Technology has 31 members and Shiv Sena MP Prataprao Jadhav heads it. The committee has not yet decided the date for its next meeting. Some opposition leaders received an alert from the ...

Parliamentary panel on IT may discuss 'Apple warning' issue in next meeting

The Parliamentary Standing Committee on Information Technology (IT) is considering summoning Apple officials during an upcoming meeting to address recent alerts on "state-sponsored attacks" sent to Opposition leaders and other public figures in the country on their iPhones,

Parliament panel may summon Apple officials over hacking attempt alerts: Report

CAMBRIDGE, Mass., Oct. 31, 2023 (GLOBE NEWSWIRE) -- Apnimed, Inc., a clinical-stage pharmaceutical company focused on developing oral pharmacologic therapies for the treatment of obstructive sleep apnea (OSA) and other sleep disorders, announced a new ...

Apnimed Announces Launch of Joint Venture with Shionogi to Develop Novel Pharmacologic Therapies for Obstructive Sleep Apnea and other Sleep Disorders

It seems that nearly half (43%) of all UK SMBs do not plan to integrate AI into their business within the next year, citing the safety of the technology as a concern ... as concerns surrounding privacy and information (34%), societal detriment (27% ...

SMEs don't want to use AI - it's not safe enough for them

Chatbots like ChatGPT wowed with their ability to do tasks as good as or better than humans, thanks to cutting-edge artificial intelligence systems.

Cutting-edge AI raises fears about risks to humanity. Are tech and political leaders doing enough?

Union Minister for Communications, Electronics & Information Technology Ashwini Vaishnaw on Tuesday (October 31) expressed concern about the issue and has vowed that the government will thoroughly investigate the incident. He remarked on the presence of ...

iPhone hacking row: Ashwini Vaishnaw responds to Apple's advisory, assures thorough investigation

The smartphone is about to evolve in a big way. For years, industry leaders pegged the arrival of 5G and foldable displays as being the technological advancements that would mark a turning point for the smartphone.

AI Is Coming for Your Phone in a Big Way

While the Temu marketplace doesn't blatantly allow products listed under Apple’s trademarked names, the items I ordered did come up when I searched the app for things like “AirPods Max” and “Apple Watch bands.

I bought these fake Apple products on the Temu app — and I was totally shocked

Appingine

appingine

This weekend I started working on a simple Web Page and decided to use Googles . Appengine Standard Environment It’s smooth sailing until you wan’t to make your website links looking pretty. By pretty I mean removing the nasty hash signs when navigating the pages. Based on $location there are two configuration options: AngularJS Docs Hashbang mode Html5 mode (only modern browsers support it) Obviously we need Html5 mode to remove the hashes. AngularJS describes Html5 mode: In HTML5 mode, the service getters and setters interact with the browser URL address through the HTML5 history API. This allows for use of regular URL path and search segments, instead of their hashbang equivalents. $location Setting up Html5 Mode is easy. First we need to add $locationProvider to Angular app config: var App = angular.module(‘App’, [‘ngRoute’]); App.config(function($routeProvider, $locationProvider) { $locationProvider.html5Mode({ enabled: true }); }); Then we need to add base href in index.html and we’re done. <head> <meta charset=”utf-8"> <base href=”/”></head> The Problem The problem is when refreshing a subpage directly(e.g. /about). To solve this we simply need to make a “url rewrite” as stated in AngularJS docs. On server such as Apache you could use .htaccess file for instance but since we’re working on Appengine we don’t have access to the server. The solution We need to tell webapp2 to map all urls to index.html. class RefreshPageHandler(webapp2.RequestHandler):def get(self):path = os.path.join(os.path.dirname(__file__), 'app/index.html')self.response.out.write(template.render(path, {})) APP = webapp2.WSGIApplication([('/about', RefreshPageHandler),('/contact', RefreshPageHandler),('/', RefreshPageHandler),], debug=True) You can find an a project example on GitHub The same solution works on any application server. See for example. this link for Java Servlets

AngularJS ng-routing links without hash bang on Appengine with Python

TL;DR The templating engine will give us the ability to use res.render() instead of res.send()
res.engine() will decide what res.render() will send Start Here We will create a directory which will contain our custom files inside. We will give it custom extension. In this tutorial, my extension will be "kanby". Lets create our custom files in that pages folder. Now its time to create our template engine. First we import required packages const express = require("express");
const fs = require("fs"); Then write that how you want your template engine to work app.engine('kanby', (filePath, options, callback) => { 
  fs.readFile(filePath, (err, content) => {

    // Error handler
    if (err) return callback(err)
    
    // process the content of file here
    // you can custumize however you want
    // this will change only #title# and #message#
    // but you can do advenced stuff with regular expressions. 
    // this example is the example used in express js docs
    const rendered = content.toString()
      .replace('#title#', `<title>${options.title}</title>`)
      .replace('#message#', `<h1>${options.message}</h1>`)
    return callback(null, rendered)
  })
}) After that, you need to define 2 more setting. app.set('views', './pages') // specify the directory for pages
app.set('view engine', 'kanby') // register the template engine Then you are ready ! You can use res.render() function to render your own files. app.get('/', (req, res) => {
  res.render('landingpage', { title: 'Hey', message: 'Hello there!' })
}) First it will render landingpage.kanby, the it will send rendered content to client. please do not forget to add status code res.status(200).render(); Future Plans This is basically an entrance for templating engine development. This is so simple. In my further blogs, i am thinking to create an advanced (usable) template engine for express JS. If you have any questions, Here is my Instagram @emrekanbay.en TL;DR The templating engine will give us the ability to use res.render() instead of res.send() res.engine() will decide what res.render() will send The templating engine will give us the ability to use res.render() instead of res.send() res.render() res.send() res.engine() will decide what res.render() will send res.engine() res.render() Start Here We will create a directory which will contain our custom files inside. We will give it custom extension. In this tutorial, my extension will be "kanby". Lets create our custom files in that pages folder. Now its time to create our template engine. First we import required packages First const express = require("express");
const fs = require("fs"); const express = require("express");
const fs = require("fs"); Then write that how you want your template engine to work app.engine('kanby', (filePath, options, callback) => { 
  fs.readFile(filePath, (err, content) => {

    // Error handler
    if (err) return callback(err)
    
    // process the content of file here
    // you can custumize however you want
    // this will change only #title# and #message#
    // but you can do advenced stuff with regular expressions. 
    // this example is the example used in express js docs
    const rendered = content.toString()
      .replace('#title#', `<title>${options.title}</title>`)
      .replace('#message#', `<h1>${options.message}</h1>`)
    return callback(null, rendered)
  })
}) app.engine('kanby', (filePath, options, callback) => { 
  fs.readFile(filePath, (err, content) => {

    // Error handler
    if (err) return callback(err)
    
    // process the content of file here
    // you can custumize however you want
    // this will change only #title# and #message#
    // but you can do advenced stuff with regular expressions. 
    // this example is the example used in express js docs
    const rendered = content.toString()
      .replace('#title#', `<title>${options.title}</title>`)
      .replace('#message#', `<h1>${options.message}</h1>`)
    return callback(null, rendered)
  })
}) After that, you need to define 2 more setting. app.set('views', './pages') // specify the directory for pages
app.set('view engine', 'kanby') // register the template engine app.set('views', './pages') // specify the directory for pages
app.set('view engine', 'kanby') // register the template engine Then you are ready ! You can use res.render() function to render your own files. res.render() app.get('/', (req, res) => {
  res.render('landingpage', { title: 'Hey', message: 'Hello there!' })
}) app.get('/', (req, res) => {
  res.render('landingpage', { title: 'Hey', message: 'Hello there!' })
}) First it will render landingpage.kanby, the it will send rendered content to client. please do not forget to add status code res.status(200).render(); res.status(200).render(); Future Plans This is basically an entrance for templating engine development. This is so simple. In my further blogs, i am thinking to create an advanced (usable) template engine for express JS. If you have any questions, Here is my Instagram @emrekanbay.en @emrekanbay.en

Template Engine For Express JS

Maggie: The Saga of a Baby Translator AI Startup

Maggie: The Saga of a Baby Translator AI স্টার্টআপ

Maggie: Die Saga eines Startups für KI-Babyübersetzer

Maggie: La saga de una startup de IA para traductores de bebés

Maggie : la saga d'une startup d'IA pour bébés traducteurs

मैगी: एक बेबी ट्रांसलेटर एआई स्टार्टअप की गाथा

マギー：赤ちゃん翻訳AIスタートアップの物語

매기: 아기 번역기 AI 스타트업의 이야기

Maggie: A Saga de um Bebê Tradutor AI Startup

Мэгги: Сага о детском переводчике, стартапе по искусственному интеллекту

Maggie: Bebek Tercüman Yapay Zeka Girişiminin Efsanesi

Maggie: Câu chuyện về một em bé dịch thuật khởi nghiệp AI

Maggie：婴儿翻译器 AI 初创公司的传奇

Last week, I decided to see the capabilities of OpenAI's image generation. However, I noticed that one has to pay to use the , while the was free, even though rate-limited. Dall.E offers samples, but I wanted to keep learning Rust. So far, I've created a . In this post, I want to describe how you can create a webapp with server-side rendering. web interface API Node.js and Python REST API The context is a runtime for asynchronous programming for Rust; is a web framework that leverages the former. I already used Axum for the previous REST API, so I decided to continue. Tokio Axum A server-side rendering webapp is similar to a REST API. The only difference is that the former returns HTML pages, and the latter JSON payloads. From an architectural point of view, there's no difference; from a development one, however, it plays a huge role. There's no visual requirement in JSON, so ordering is not an issue. You get a struct; you serialize it, and you are done. You can even do it manually; it's no big deal - though a bit boring. On the other hand, HTML requires a precise ordering of the tags: if you create it manually, maintenance is going to be a nightmare. We invented to generate order-sensitive code with code. templating While templating is probably age-old, PHP was the language to popularize it. One writes regular HTML and, when necessary, adds the snippets that need to be dynamically interpreted. In the JVM world, I used <abbr title="Java Server Pages">JSP</abbr>s and Apache Velocity, the latter, to generate RTF documents. Templating in Axum As I mentioned above, I want to continue using Axum. Axum doesn't offer any templating solution out-of-the-box, but it allows integrating any solution through its API. Here is a small sample of templating libraries that I found for Rust: , based on Handlebars handlebars-rust , based on Liquid liquid , based on Jinja, as the next two Tera askama MiniJinja etc. As a developer, however, I'm lazy by essence, and I wanted something integrated with Axum out of the box. A quick Google search lead me to , which seems pretty new but very dynamic. The library is an abstraction over handlebars, askama, and minijinja. You can use the API and change implementation whenever you want. axum-template axum-template in short Setting up axum-template is relatively straightforward. First, we add the dependency to Cargo: cargo add axum-template Then, we create an engine depending on the underlying implementation and configure Axum to use it. Here, I'm using Jinja: type AppEngine = Engine<Environment<'static>>;                 //1

#[derive(Clone, FromRef)]
struct AppState {                                              //2
    engine: AppEngine,
}

#[tokio::main]
async fn main() {
    let mut jinja = Environment::new();                        //3
    jinja.set_source(Source::from_path("templates"));          //4
    let app = Router::new()
        .route("/", get(home))
        .with_state(AppState {                                 //5
            engine: Engine::from(jinja),
        });
} Create a type alias Create a dedicated structure to hold the engine state Create a Jinja-specific environment Configure the folder to read templates from. The path is relative to the location where you start the binary; it shouldn't be part of the folder. I spent a nontrivial amount of time to realize it. src Configure Axum to use the engine Here are the base items: is a facade over the templating library Engine Templates are stored in a hashtable-like structure. With the MiniJinja implementation, according to the configuration above, is simply the filename, , Key e.g. home.html The final parameter has no requirement. The library will read its attributes and use them to fill the template. S I won't go into the details of the template itself, as the is quite good. documentation The impl return It has nothing to do with templating, but this mini-project allowed me to ponder the return type. In my previous REST project, I noticed that Axum handler functions return , but I didn't think about it. It's indeed pretty simple: impl impl If your function returns a type that implements , you can write its return type as . This can help simplify your type signatures quite a lot! MyTrait -> impl MyTrait -- Rust by example However, it has interesting consequences. If you return a single type, it works like a charm. However, if you return more than one, you either need a common trait across all returned types or to be explicit about it. Here's the original sample: async fn call(engine: AppEngine, Form(state): Form<InitialPageState>) -> impl IntoResponse {
    RenderHtml(Key("home.html".to_owned()), engine, state)
} If the page state needs to differentiate between success and error, we must create two dedicated structures. async fn call(engine: AppEngine, Form(state): Form<InitialPageState>) -> Response {                     //1
  let page_state = PageState::from(state);
  if page_state.either.is_left() {
    RenderHtml(Key("home.html".to_owned()), engine, page_state.either.left().unwrap()).into_response()  //2
  } else {
    RenderHtml(Key("home.html".to_owned()), engine, page_state.either.right().unwrap()).into_response() //2
  }
} Cannot use ; need to use the explicit type impl IntoResponse Response Explicit transform the return value to Response Using the application You can build from the source or run the Docker image, available at . The only requirement is to provide an OpenAI authentication token via an environment variable: DockerHub docker run -it --rm -p 3000:3000 -e OPENAI_TOKEN=... nfrankel/rust-dalle:0.1.0 Enjoy! Conclusion This small project allowed me to discover another side of Rust: HTML templating with Axum. It's not the usual use case for Rust, but it's part of it anyway. On the Dall.E side, I was not particularly impressed with the capabilities. Perhaps I didn't manage to describe the results in the right way. I'll need to up my prompt engineering skills. In any case, I'm happy that I developed the interface, if only for fun. The complete source code for this post can be found on . GitHub To go further: Axum axum-template MiniJinja Dall.E webapp Image generation API Originally at on April 30, 2023. published A Java Geek

Showcasing Server-side Rendering in Rust — A Dall.E Use-case

Platform-as-a-Service (PaaS) is a much misunderstood but still overused cloud term. It doesn’t help that different technology/cloud vendors define it differently. There are also mini variants of PaaS like application PaaS (managed compute services for hosting applications), integration PaaS (for providing integration services between disparate applications and systems), communication PaaS (for providing communications services like voice, SMS, email, etc.), and many others. Many core services such as managed databases (DBaaS) are also sometimes referred to as a kind of PaaS. Effectively every service, API, etc. that reduces the burden of infrastructure management or provides an easy-to-use abstraction over repetitive tasks is now referred to as PaaS. In this article, however, I want to focus on the original definition of PaaS — managed compute environment that just takes the code (or built executables) from developers and runs it for them, removing the need for VM management. This is sometimes referred to as application PaaS (aPaaS) and is an area that has gone through some interesting cycles. Initially touted as “ ”, it lost steam as infrastructure-as-a-service (IaaS) still provided the easiest and most friction-free vehicle for both lift-and-shift workloads as well as new applications. Many said PaaS was too restrictive, or required too much change to application architecture or deployment workflows, did not provide enough control over underlying resources, etc. this is what cloud should be Many of us have might have seen diagrams similar to this one talking about the compute continuum with control on one end and convenience on the other. This is what the original version looked like: In recent years, however, two new hotter compute trends have dominated the narrative a lot more than PaaS — Kubernetes and Serverless. Both sit on either side of PaaS on the compute continuum. Kubernetes makes infrastructure management easy. Serverless has multiple definitions depending on which cloud vendor you talk to but the most common one is event-driven, pay-per-use, autoscale compute provided via a Functions-as-a-Service (FaaS) model. This makes the updated version of the cloud compute continuum look like this: A while ago, I even waxed eloquent about the virtues of serverless . here However, the reality is that most of these technologies (Kubernetes, PaaS, Serverless) come in various flavors and depending on the flavor, fall at different places on the continuum. This means that the cloud compute continuum now contains multiple axes. For simplicity, let us consider only two: Whether a compute solution solves for infrastructure or for application workflows Whether the underlying machinery needs to be managed by the user or is managed by the cloud provider Let us also make a third simplifying (although potentially controversial) assumption that things like Serverless/FaaS are just a subset of PaaS, at least based on the original definition of PaaS (focus on apps, not infrastructure). With these in mind, this is what the continuum begins to look like: Let us look at all of these stops on the continuum: : This is easy. Virtual Machines that you need to manage yourself. Install application runtimes, perform patching, etc. all yourself. These are popular, even among developers. I talk about some of the reasons . (1) IaaS here Examples of IaaS: https://aws.amazon.com/ec2/ https://cloud.google.com/compute https://www.digitalocean.com/products/droplets/ : Most cloud providers these days offer virtual machine images that come pre-packaged with application stacks so that developers can just start writing or deploying code immediately after spinning up instances of these VM images. I prefer to call them “starter templates” for IaaS instead of calling them PaaS. They do solve for some application workflows but still leave too much infrastructure maintenance work for developers. Examples: (2) VM Marketplace https://aws.amazon.com/marketplace/ https://www.digitalocean.com/products/marketplace/ : Kubernetes allows you to manage your infrastructure better but lacks the concept of an “application”. Managing it yourself can be complex but many experts prefer to do it. The appeal for doing this can be understandable especially for those who choose an infrastructure-centric technology like Kubernetes in the first place. (3) Self-hosted Kubernetes : Almost every serious cloud provider these days has a managed Kubernetes offering that does a certain set of Kubernetes management. While most of these offerings do not help with application-centric concepts, they do reduce the burden of operating Kubernetes itself. Examples: (4) Managed Kubernetes https://aws.amazon.com/eks/ https://cloud.google.com/kubernetes-engine/ https://www.digitalocean.com/products/kubernetes/ One common misunderstanding is that containers and Kubernetes go hand in hand. This is not entirely true. While Kubernetes works great for containerized workloads, containers are useful in other contexts also. I talk about this topic in . this article : This is an area I never understood the need for. In my mind, someone who is looking for a PaaS solution has already made the decision that they want to focus on application development rather than infrastructure management. If so, then why get into the business of self-hosting a PaaS solution where you are still responsible for the underlying infrastructure? Anyway, there are solutions that do this for you — also referred to as DIY PaaS. The idea is that a “platform team” does some initial setup (and maybe a little bit of ongoing maintenance) for this PaaS on their own infrastructure (VMs or Clusters), and then the experience that everyone else (folks building apps within the same organization) gets is that of a PaaS. They just get to focus on their applications. Examples: (5) Self-hosted PaaS https://marketplace.digitalocean.com/apps/jelastic-paas https://marketplace.digitalocean.com/apps/caprover https://www.cloudfoundry.org/ https://www.openfaas.com/ : This is true PaaS that truly brings the “aaS” piece into meaning. In my mind “as a Service” means something I can expect and consume as an entity without worrying about how that entity was built or is being delivered to me. This is what fully managed PaaS offerings begin to provide — freedom from infrastructure management. Examples: (6) Managed PaaS https://cloud.google.com/appengine/ https://azure.microsoft.com/en-us/services/app-service/ https://www.heroku.com/platform : Wait. What? Didn’t I say earlier in this article that Kubernetes is an infrastructure-centric technology? Then why would I bring that into a discussion about fully managed PaaS solutions supposed to be all about applications? Well, the truth is that any serious managed PaaS solution needs to be built atop some kind of an orchestration layer that manages multiple instances of compute underneath. And right now, Kubernetes is the de facto standard for compute orchestration in our industry. The amount of mindshare, resources, focus, and energy it is getting, is ensuring that its quality continues to improve. Here are some thoughts from experts: (7) Managed PaaS on Kubernetes So, although it might sound like an implementation detail that the developers may not care about, but the reality is that a managed PaaS built on Kubernetes will always be more flexible and “future-ready” than the alternatives. Examples: https://www.digitalocean.com/products/app-platform/ : And yes. Finally, that thing about scale. In order for a solution to truly be application-centric, it needs to be able to handle scale — both up and down — without requiring the app developer to worry about how to add/remove infrastructure. Some serverless FaaS solutions do this today but then they are limited to the Functions programming model thereby requiring a little more work to bring existing applications into this fold. We need more PaaS solutions (even classic aPaaS) to move in this direction. I suspect even here, Kubernetes and many of its associated projects such as would prove to be the trusted technologies to build on. Examples: (8) Managed PaaS with autoscale knative https://cloud.google.com/run/ https://aws.amazon.com/lambda/ https://azure.microsoft.com/en-us/services/functions/ Hopefully, this article gives you a clearer picture of various types of compute solutions available to you along with examples, and how to think about various alternatives depending on your appetite for infrastructure management. Also published here.

On the Original Definition of PaaS

When you you also automatically get , which lets you work with our built-in databases on your site. You may also want to work with data that you maintain in an external database. Velo lets you connect your site to an external database and then work with that database collection in your site just as you would with our built-in collections. enable Velo Wix Data That means that you can display data from an external collection in Editor elements, use the data to create dynamic pages and connect it to user input elements. You can learn about adding an external database to your site . To work with external database collections you need to create an external database adapter. This adapter implements a Service Provider Interface (SPI) that enables your site to communicate with your external database collection. This is the basic structure of the system: here Let's look at each step in more detail: . A data request is generated by your Wix site and sent to your adapter. A data request can be the result of any visitor activity that relates to your collections or code you add that calls the wix-data API. This request is in the form of a REST API call. The request payload includes specific information about the request. Site data request . The adapter receives the request. It converts that request into an API request that your external database can receive, based on the external database's API. Adapter translation of data request . The data request is sent to your external database using your external database's API. Adapter data request . Your external database responds to the request, based on its API. External database data response . The adapter receives the response. It converts this response into a response to the REST API request it received from the site. Adapter translation of data response . The adapter sends the response to your site, including response payload information, and your site automatically handles the response and its payload. Adapter data response Adapter Implementations Wix has created the following prototype adapters on GitHub that you can experiment with and adapt to your needs: Adapter for MySQL databases deployed to Google AppEngine Adapter for Google Cloud Firestore with Cloud Run or AppEngine Follow the steps in the README file to deploy and test the prototype adaptor. Building the Adapter The adapter takes the request from your Wix site and converts it into something your external database can receive. It also takes the response from the external database and converts it into something your Wix site can receive. This is where you come in. You need to build the adapter that implements the SPI and translates requests and responses between the two systems. To create the code in your adapter you'll need to understand the structure of the API requests that your site can send to your adapter, and the structure of their associated payloads. You can find that information . here You'll also need to understand your external database's API. You'll need to understand the format that it expects as a data request as well as the format it uses in its responses. Your Wix site and your external database will handle their parts. The critical steps in the process, and the ones you need to manage, are steps 2 and 5. You can see an example implementation of an adapter . here Step 2 - Adapter translation of data requests from your Wix site to the external database Your Wix site sends an API request, but it is not in a format that your external database can work with. You need to add code in your adapter to: Take the request and its payload from the Wix site and convert it into a request that the external database can receive. Send that requests to the external database in a form it can receive. Step 5 - Adapter translation of data requests from the external database to your Wix site Your external database will receive the request from your adapter and send a response back. This response will be in a format native to your database, but your Wix site can't work with that response. You need the code in your adapter to: Receive the response from the external database. Convert that response into a response and payload that your Wix site can receive and send it back to your Wix site. Important Information for Building Your Adapter The following is information you need to consider when building your adapter and managing your database. _id Each table or collection must contain an _id column or attribute of type string. The Wix Data backend will generate a unique 36-character UUID for each item created in your site. The `_id` can be any length, but if items are created by your Wix site, it must be at least 36 characters long. _owner (optional) The Wix Data backend will send an owner ID when creating a new data item. This is a 36-character UUID identifying the user who created the data. Use the _owner field to sort or filter data by user. Dates All dates must be an ISO string encapsulated in an object. For example: "myDate" :{“$date”:”2001-02-11T00:00:00.000Z”} Authentication The External Database Collections SPI uses the request context object to manage authentication and authorization. HTTP authentication is not implemented. The settings object within the request context object can be used to send a key for authentication purposes. In the prototype, the secretKey property is used and used to authenticate each request. The settings object is defined in the Wix Editor when , and sent by the Wix Data backend with every request. adding the external collection Permissions for external databases Velo's built in collections include a , which you can use with your external collections as well. You can also implement your external collection's permissions model, based on how you implement your adapter. Using the members, you can set permissions based on any of the following: permissions model context object's instanceId - the Wix site making the request. installationId - the external collection defined in your site making the request. memberId - the id of the site visitor making the request. role - whether the visitor is the owner, a member or a guest. You  can also control access to your external collections based on which endpoints you implement in your adapter. See below for a description of the required and optional endpoints. The datasets on your site recognize which endpoints were implemented in the adapter. For example, if you only implement endpoints that read data, the dataset mode will be read-only. You can view a read-only version of your collection's permissions in the . Site Structure sidebar Required and optional endpoints The following endpoints are mandatory and must be implemented in your adapter. All other endpoints are optional. Find Schemas Discover the database tables  or collections that are visible to your database user. List Schemas List the details of a given list of database tables or collections. Get Item Get a specific database row or item based on the item's _id field. Find Items Get a list of items based on a filter. Count Get the number of rows or items in a table or collection. Provision Establish the connection between your site and your adapter. Working with reference fields You cannot work with in external database collections. You can only use single references in external databases, with the following implementation rules: multiple item reference fields The reference must point to an _id field. The reference field must be of type string. To allow references from other collections to the external collection the _id field needs to accept the hasSome filter. Working with dynamic pages To use Dynamic Pages with external collections at least one of the fields needs to accept the urlized filter. That field will be used for generating dynamic page links. Previously published at https://support.wix.com/en/article/velo-working-with-external-database-collections

How To Work with External Database

Step-by-Step Guide on How to Use External Database Collections for Better Wix Website Performance

A couple of months ago, our suffered a 44 minute API outage. It was the first period of downtime we had experienced in over 18 months, and it was really, really frustrating. You can . feature flagging platform read our post-mortem here For us, the troubling part was that the code that broke production had worked perfectly in our staging environment, which is running on an identical stack. How did this happen? A discrepancy in data between the two environments caused a database migration to fail which in turn knocked us offline. This code had sailed through both our automated tests and staging environment builds multiple times, with green ticks all the way. This gave us a false sense of security around deploying what was a fairly significant code change to production. It got us thinking; if green builds in staging can still cause a catastrophic outage, what is the point in staging? Why do we even have staging environments? The goal of a staging environment is to provide a safe place for teams to test their software in an “as-close-to-production-as-possible” environment. As we saw from my example, there is always an opportunity to miss something, rendering the test invalid. So why not just test in production? Over the last 25 years building software, I have lived through many evolutions and approaches to building software. In almost all of them, staging has been accepted because “we’ve always done it this way”. Taking a first-principles approach to challenging this concept, I thought through the most important changes to building software that I’ve been experienced: Collaborative Code (Git) Many teams still struggle to collaborate on code today, but imagine (or think back to) the world without version control. In the late 90’s I remember working in a team passing around USB drives that contained the code we had been working on. While there was some version control software at the time, the adoption was nowhere near what it is with Git today. Building software as a team was extremely difficult and managing source code was a regular pain. The largest pain points came when you needed to bring everyone’s individual work together and merge. Oftentimes this was owned by a senior developer who would work to create a successful build with the underlying components and run them in a staging environment. Automated Testing (Selenium) Any software build process that I’ve been involved in, testing has always been a key step before deployment. With that being said, there has been a massive shift from a focus and resource perspective from “testing” to “production testing” software. The first milestone that I experienced was no doubt automated testing. Today, people take for granted the world we live in when it comes to testing software. Prior to 2004 and the launch of , the world we built software within was about unit tests. Basically, you tested the parts and hoped that the sum was at least equal. Selenium allowed us, as developers, to focus on the end user functionality vs. the interoperability of components. This trend has accelerated to the point where we now . Selenium argue over whether unit testing even makes sense Zero Downtime Deployments (Virtualization, Containerization) Thankfully, scheduled downtime is a thing of the past. In 1999 I was consulting at a big credit card company in the UK. They had a bunch of Sun E10K servers powering their platform. When they wanted to deploy a new release, they would wait until midnight, go into the server room (which was located in the next office, obviously) and pull the fibre optic cable out of the wall. Then 3 hours later, when the new build was running, they would plug it in again. As you can see, there were tons of opportunities for errors because of the sheer nature of what we were doing. They also took time, and so doing them manually multiple times a day would have been out of the question. Achieving Zero downtime deployments that run regularly and reliably can be tricky, and can depend a lot on your technical stack. Platforms like Heroku and AppEngine popularized this approach and provide these features out of the box, but achieving them with a more legacy stack can be much more difficult. With that being said, for teams that are able to run deployments without downtime, the need for staging is drastically reduced. Testing in Production (Feature Flags / Toggles) Perhaps the most recent improvement to reducing the need for staging environments has been the ability to decouple the concept of deploy and release in software. This shift in approach was popularized when he introduced the concept of feature toggles and their ability to help teams test features in production vs. staging. in this article by Martin Fowler The basic concept of feature flags / toggles is that you deploy the code to production, but you “hide” the feature behind a flag or toggle until you are ready to introduce it to your user base. The core benefit of this approach is that everything your team builds can now be exposed to the actual production environment and you are able to do the most powerful form of making sure your code isn’t broken: testing in production. From this simple concept, many different flavors have arisen: Canary Releases, Kill Switches, Feature Flags, Remote Config, and A/B Testing. Stop and think about the underlying benefit of “staging” as we have used it historically. It’s goal is to allow teams to test their code in an environment that is as close to production as possible. Why haven’t we completely evolved to eliminate staging all together? OK I get all that, but I’m still terrified… We believe that there are five engineering pillars that you need to implement before you can consider removing your staging environment. The good thing is that all of these focus points are great engineering practises anyway; so if you really feel like you aren’t ready to delete it just yet, you still get a tonne of benefit from these five pillars. Pillar 1: A culture of code review and pair programming Git/GitHub/GitLab have had a hugely beneficial impact on being able to collaborate on code as a team. Code reviews used to involve (if they happened at all!) pulling up a chair and looking at some files in the IDE of the person that wrote the code. Nowadays, the Merge Request UIs in GitHub/GitLab are critically important parts of the engineering process, allowing teams to collaborate on code review in a way that was just not possible back in the day. Without a staging environment, writing core application code that could cause downtime or a loss in revenue might seem daunting, but it’s important to remember that pair programming is a super helpful process in this situation, and the tools to perform pair programming, in particular in a remote working environment, are getting better all the time. If you are nervous about the code you are writing, grab a colleague! Pillar 2: Automated Testing, build pipelines, and zero-downtime deployments If you are pushing to production multiple times a day, you need to be able to rely on the tooling you use to get that code into production. The goal is to prevent any bugs ever getting to production. That’s impossible, but you can work on catching as many as you possibly can! This means really good test coverage across your entire code base. That includes unit testing, integration testing, end to end testing, browser testing, and then non-functional testing like latency/performance Pillar 3: Decoupling deploy and release Feature Flags are instrumental in being able to test in production, and being comfortable deploying code regularly whilst maintaining control over the actual release of the feature itself. Using a feature flagging platform like Flagsmith allows you to be really expressive in terms of who sees your new features and when they see them. You can use tools like Flagsmith to show new features to individuals and specific groups of users before rolling them out to your wider audience over time. Pillar 4: Really good monitoring That doesn’t mean pointing Pingdom at one API endpoint and you’re done! You need to monitor your stack at a variety of points: Test meaningful API endpoints that connect with your datastores and any other third party services that you rely uponTest non functional aspects like latency, load and overall end client performance using tools like .Have an alerting system that people use and that works!Pillar 5: Meaningful post mortems DebugBear It’s really important to keep in mind that bugs will happen, and outages will happen, regardless of whether you have a staging environment or not. The thing to remember is that you can work to reduce these outages through processes and tools, but the most important way you can reduce bugs and outages is with meaningful post mortems: always always Carry out a root cause analysis on what happened and whyCommunicate that with your team and your users about what happened, what you have learnt and how you are going to use that learning to improve. Figure out how to prevent it from happening again in the future. This is the hard part! It will likely consist of a combination of new code, infrastructure and processes. I really like staging though? You can take small steps to get there. There are a bunch of things you can do to dip your toe in the water and get a feel for what life would be like without staging. If you have a web application, deploying the web front end is a perfect candidate as the first component in your stack going straight to production. There are a number of reasons for this: Platforms like provide great integrations with git and allow you to version every single push of your application, allowing you to easily roll back if something goes wrong.Front end web applications lend themselves perfectly to feature flagging. Using flags to show and hide UI elements is their primary use case, so you can leverage flags to their full effect. Front ends are generally stateless, meaning you don’t have to worry about thorny issues like database migrations.If your front end is working against a stable API, you don't really need to worry about versioning compatibility with other parts of your stack. Vercel Another option is to select some less invasive features and branches that don't really get any benefit from going through the staging and sign off process. If you have a feature branch that updates copy or changes styling in your application, that is a prime candidate to go straight to production. Should you kill your staging environment? Depending on where you are in your product team lifecycle, implementing these pillars may well involve a lot of work. It’s much easier to implement them and their processes at the beginning of a project. The thing to remember is that, regardless of the end state, working on these pillars will get you a ton of benefits, even if you don’t turn off your staging environment… just yet. These pillars will definitely help improve your overall velocity and code quality. If you start off deploying smaller features directly to production, you can increase the scope of this over time. One day you may well realise that you haven’t pushed anything through the staging environment for weeks. In many ways, removing staging can be seen as a panacea. For some teams, and some products, it’s just too hard, for whatever reason (and some of them will be good reasons!). For us at Flagsmith, we are going to split out our production API between the (very!) high traffic SDK API and everything else that powers our dashboard. For the “everything else” part of the API, we have a goal of deploying to production for that API. But for a piece of infrastructure that serves thousands of requests per second, 24 hours a day, and that hundreds of companies rely on to power their feature flags, we’re just not ready for that yet. And we’re fine with that. For now. Previously published on https://www.flagsmith.com/blog/delete-your-staging-environment

Do You Really Need Staging Environment?

I like to analyze my past work through the prism of evaluating my mistakes (I’m sure my therapist would have a field day with that one). I launched my first publicly available engineering project in early December and as George W. Bush once said, “Mistakes were made”. I studied CS at Carnegie Mellon for undergrad and as part of my classes I built a number of projects. But it’s one thing to build something for a class where maybe one or two people will use it for a brief period and another altogether to ship something for the general public. Upon graduation I worked at Google for 3 years where, as you can imagine, they make it pretty much impossible for junior engineers to royally screw anything up (though I still found a way to, but that’s a story for another day). After about a year of operating as a traditional recruiting agency (where we also made ), my co-founder (and twin) had learned enough to launch a free software product to help engineers find new jobs in a non-annoying and non-spammy way. For about three months I was heads down building our tool that would index open engineering jobs across the internet then hand-match an engineer to 5 job openings each month that matched their preferences and qualifications. plenty of mistakes While I was maniacally coding my brother was building our beta audience of early users. By the time we were ready to launch we had 142 users completely signed up and ready to receive our job recommendations (we’ll talk about the mistakes we made in building that audience in our next post). After launching it took me all of a minute to realize I made a big mistake. Talk about a let-down. All-in-all our beta launch has been a success. We’ve gotten really positive feedback from our early users, we know exactly what features we need to work on next, and we have a better sense of what kind of engineers find the most utility out of our tool. But my goal here is to highlight the engineering mistakes I made to help you avoid the same ones when you launch your next project. I also want to have this as a reference so I never repeat these errors. 1. Didn't test properly (or the horrible, no good, very bad start) In order to receive job recommendations from us you have to complete a basic form so we know what kind of engineering roles you’re looking for and where. Now, before we had that form built we threw up a landing page and collected emails to see if people would be interested in what we were building. When the signup form was ready we emailed our mailing list prompting them to complete that form. This was a really big moment for us. Anyone who completed the form would officially receive our job recommendations! My brother wrote the email, nervously hit send, and less than two minutes later we had four emails letting us know the form didn’t work. Womp womp. This was one of the lowest moments in our company’s history. We never wanted to be a recruiting agency. We did that for a year to learn what software product we could build to help engineers learn about new jobs. When we were in the drudges of recruiting the launch of a software product was the light at the end of the tunnel. So now, in our first big moment for that product, something was wrong. We tested that form. We tested it robustly with different inputs. We really, really tried to break it. So what happened? When I built the signup form I had to change the way our backend was structured. When we were just collecting email addresses we didn’t need much of a schema. But now we had users and attributes about those users so we needed a real database structure. When the new schema was built we migrated all of the people who signed up with their emails to this new schema. When these people then tried to complete our signup form they got an error saying “this user already exists”. When we had tested the form we only tested it with new email addresses not in our system. Luckily, we were able to quickly fix the error (after 5 minutes of pure panic) with the help of these very generous early adopters. This seems like such an egregious error in hindsight. It’s funny, I’m a solid developer but when working on this project I was juggling so many balls in the air that I made some basic mistakes. At Google I was bowling with bumpers. When those bumpers got removed it’s like I had to re-learn some of the basics. Some things you only really learn by messing them up and I can assure you I won’t make this mistake again. 2. DevOps will be the death of me Let me preface this section by saying I don’t know anything about DevOps. As in, I almost never deployed code to my own server. So when building this project I was looking for a service where I could push code to production and our site just worked with little tuning or configuration involved on my end. I worked on the Google Cloud team during my Google tenure so I figured that’s what I should use when launching this project. This was a mistake (I’ll expound on the reasons why next). The overall lesson here is that I should have avoided the and ditched GCP when there were early signs that it wasn’t what I was looking for. sunk cost fallacy My experience with GCP and AppEngine was not at all what I wanted. I assumed that AppEngine would be flexible enough to easily cater to our stack (Django, Angular, and at the time MySQL). I also assumed that AppEngine and any other Google Cloud Product like CloudSQL would work nicely together with little configuration. I just got too many errors I didn't know how to handle and there was little documentation or support online when you Googled (or DuckDuckGod or Bingd or AltaVistad) the error. The straw that broke the camel's back and forced us to switch off GCP was the inability to deploy code to production for two weeks. I have a feeling if you know what you're doing, the user-experience of using AWS vs Azure vs GCP is largely the same (though I could be wrong about this). What's frustrating is that even though I'm directly in the demographic of people these platforms want to attract, they don't focus much attention on me. We’ve since switched to Heroku and I no longer worry about making sure our site stays up and running. It’s a bit more expensive (about $125 a month for us vs $50 for Google) but I place the value of my time and mental well-being at greater than $75 a month so we’re okay with this trade-off. 3. Got a case of "shiny object syndrome" If you frequent forums or podcasts about startups I’m sure the phrase “Minimum Viable Product” (MVP) has lost all meaning to you. It’s used so commonly to describe vastly different products and product stages that it has just become another space on the board of “startup bingo”. To me, the fundamental idea of an MVP is to build the most basic version of your product to test if people will use it and to learn how to improve that product for the next version. If there is a prevailing hypothesis in this blog post it is the gap between reading and doing is the size of the Grand Canyon. Sure, I knew that v1 of what I was building should be pared down as much as possible. If you look at the original list of features we thought needed to be in this version I would say we got 90% of the way there. Still, I let a cool engineering/math challenge inflate the work I should have done. In our first version of the product my tool would whittle down thousands of engineering jobs for a given person to a list of about 30 jobs based on qualifying factors like location, job title, years of experience, etc... Then, from that list my co-founder and I would manually select 5 jobs each month that we thought were the best fit for that person. You know what we didn’t need for this version? A convoluted way to score and sort the remaining list of 40-50 jobs to save us time in choosing the top 5. I spent a lot of time coming up with a clever way to weight factors that I thought mattered to engineers in determining if a given job is what they’re looking for. As it turns out, the data we were automatically collecting on all of these jobs was not yet clean or standardized enough to make that score meaningful. We quickly scrapped this ranking system because there was no correlation between the score and the likelihood we would choose a job for a given engineer. All in, this took me about two days to develop which would have been way better spent getting our product in front of users earlier to start getting feedback. Mistakes were made - a reflection I hope that reading this will help save you time and angry typing into your computer when you launch your next project. I know I’ll continue to mess up, it’s just the nature of trying to build something new. What I want to avoid at all costs is messing up in the same way over and over. So I’ll write these posts on a semi-regular basis. I’ll also try to write about some of my successes because despite the premise of this article, things are going pretty well for us right now! We have users who really like our product and we’re solving a problem in a space we think is completely dysfunctional for job seekers. Until my next post, happy building. Previously published at https://www.beamjobs.com/blog/how-i-botched-my-companys-launch-after-leaving

Bye Bye Google: How I Botched My Company's Launch After Leaving

The technology that allows us to run our Angular applications on the server is described in the Angular docs as Angular Universal. generates application pages on the through a process called . It can generate and serve those pages in response to requests from browsers. It can also pre-generate as HTML files that you serve later. Angular Universal static server server-side rendering (SSR) Angular template A normal Angular application executes in the , rendering pages in the DOM in response to user actions. browser In order to improve the user experience, we want to render the pages server side and send the generated static content to the client side, this will ensure that our content is crawlable by search engines and also allow users with  feature phones to consume our content. In this article you will learn how to add Angular Universal support to any existing Angular app. Let’s get started by installing dependencies Server Side Rendering  – Install dependencies In order to implement server side rendering we need to install some additional dependencies. Open Terminal enter the following commands: $ npm install --save @angular/platform-server @nguniversal/ -map-ngfactory-loader ts-loader @nguniversal/express-engine module The root AppModule Open file and find the import in the metadata. Replace that import with this one: src/app/app.module.ts BrowserModule NgModule BrowserModule.withServerTransition({ : }), appId 'your App-ID' Create an file in the directory with the following AppServerModule code: app.server.module.ts src/app/ { NgModule } ; { ServerModule } ; { ModuleMapLoaderModule } ; { AppModule } ; { AppComponent } ;
 
@NgModule({ : [
    AppModule,
    ServerModule,
    ModuleMapLoaderModule
  ], : [ ], : [ AppComponent ],
}) {} import from '@angular/core' import from '@angular/platform-server' import from '@nguniversal/module-map-ngfactory-loader' import from './app.module' import from './app.component' imports providers // Add universal-only providers here bootstrap export class AppServerModule Create a file in the src directory with the following code: main.server.ts ; ; { enableProdMode } ; * express ; { join } ; enableProdMode(); app = express(); PORT = process.env.PORT || ; DIST_FOLDER = join(process.cwd(), ); { AppServerModuleNgFactory, LAZY_MODULE_MAP } = ( ); { ngExpressEngine } ; { provideModuleMap } ;

app.engine( , ngExpressEngine({ : AppServerModuleNgFactory, : [
    provideModuleMap(LAZY_MODULE_MAP)
  ]
}));

app.set( , );
app.set( , join(DIST_FOLDER, )); app.get( , (req, res) => {
  res.status( ).send( );
}); app.get( , express.static(join(DIST_FOLDER, ))); app.get( , (req, res) => {
  res.render(join(DIST_FOLDER, , ), { req });
}); app.listen(PORT, () => { .log( );
}); // These are important and needed before anything else import 'zone.js/dist/zone-node' import 'reflect-metadata' import from '@angular/core' import as from 'express' import from 'path' // Faster server renders w/ Prod mode (dev mode never needed) // Express server const const 4000 const 'dist' // * NOTE :: leave this as require() since this file is built Dynamically from webpack const require './dist/server/main.bundle' // Express Engine import from '@nguniversal/express-engine' // Import module map for lazy loading import from '@nguniversal/module-map-ngfactory-loader' 'html' bootstrap providers 'view engine' 'html' 'views' 'browser' // implement data requests securely TODO: '/api/*' 404 'data requests are not supported' // Server static files from /browser '*.*' 'browser' // All regular routes use the Universal engine '*' 'browser' 'index.html' // Start up the Node server console `Node server listening on http://localhost: ` ${PORT} Tip : This sample server is not secure! Create a file in the directory to configure TypeScript and AOT compilation of the universal app. tsconfig.server.json /src { : , : { : , : , : , : []
  }, : [ , ], : { : }
} "extends" "../tsconfig.json" "compilerOptions" "outDir" "../out-tsc/app" "baseUrl" "./" "module" "commonjs" "types" "exclude" "test.ts" "**/*.spec.ts" "angularCompilerOptions" "entryModule" "app/app.server.module#AppServerModule" Create a file in the project root directory with the following code. webpack.server.config.js path = ( ); webpack = ( ); .exports = { : { : }, : { : [ , ] }, : , externals: [ ], : { : path.join(__dirname, ), : }, : { : [{ : , : }]
  }, : [ webpack.ContextReplacementPlugin( ,
      path.join(__dirname, ), {} ), webpack.ContextReplacementPlugin( ,
      path.join(__dirname, ),
      {}
    )
  ]
}; const require 'path' const require 'webpack' module entry server './server.ts' resolve extensions '.js' '.ts' target 'node' // this makes sure we include node_modules and other 3rd party libraries /(node_modules|main\..*\.js)/ output path 'dist' filename '[name].js' module rules test /\.ts$/ loader 'ts-loader' plugins // Temporary Fix for issue: https://github.com/angular/angular/issues/11580 // for 'WARNING Critical dependency: the request of a dependency is an expression' new /(.+)?angular(\\|\/)core(.+)?/ 'src' // location of your src // a map of your routes new /(.+)?express(\\|\/)(.+)?/ 'src' Update apps section of .angular-cli.json : [{ : , : , : [ , ], : , : , : , : , : , : , : , : [ ], : [], : , : { : , : }
 },
 { : , : , : , : [ , ], : , : , : , : , : , : , : [ ], : [], : , : { : , : }
 }
], "apps" "root" "src" "outDir" "dist/browser" "assets" "assets" "favicon.ico" "index" "index.html" "main" "main.ts" "polyfills" "polyfills.ts" "test" "test.ts" "tsconfig" "tsconfig.app.json" "testTsconfig" "tsconfig.spec.json" "prefix" "app" "styles" "styles.css" "scripts" "environmentSource" "environments/environment.ts" "environments" "dev" "environments/environment.ts" "prod" "environments/environment.prod.ts" "platform" "server" "root" "src" "outDir" "dist/server" "assets" "assets" "favicon.ico" "index" "index.html" "main" "main.server.ts" "test" "test.ts" "tsconfig" "tsconfig.server.json" "testTsconfig" "tsconfig.spec.json" "prefix" "app" "styles" "styles.css" "scripts" "environmentSource" "environments/environment.ts" "environments" "dev" "environments/environment.ts" "prod" "environments/environment.prod.ts" Build and run with universal Now that you’ve created the TypeScript and Webpack config files, you can build and run the Angular Universal application. First add the and commands to the scripts section of the : build serve package.json : {
    ... : , : , : , : ,
    ...
} "scripts" "build:universal" "npm run build:client-and-server-bundles && npm run webpack:server" "serve:universal" "node dist/server.js" "build:client-and-server-bundles" "ng build --prod && ng build --prod --app 1 --output-hashing=false" "webpack:server" "webpack --config webpack.server.config.js --progress --colors" Build Universal From Terminal, type: npm run build:universal Serve Universal After building the application, start the server. npm run serve:universal Finally. Open a browser window to and access your Server-side rendered Angular app. http://localhost:4000/ Conclusion With server-side rendering, we can ensure that search engines, browsers with disabled, or browsers without Javascript can still access our site content. Javascript References https://codesource.io/build-a-server-monitoring-app-using-node-angular/ Previously published at https://codesource.io/server-side-rendering-in-angular/

Stories, News & Mentions about APPINGINE

Appingine’s Stories on HackerNoon

Appingine's News & Mentions