Take a step ahead in business management with your portable manager- Runo. A seamless and easy set-up CRM app that offers a modern mode of managing outbound sales and tele- calling processes. Including features such as Caller Id, call recording, live team status, real-time performance analytics, and follow-up notifications among many, this sim based app does it all on the go!

Runo

runo

Any views expressed in the below are the personal views of the author and should not form the basis for making investment decisions, nor be construed as a recommendation or advice to engage in investment transactions. Mayday Mayday Mayday Some of you degens were screaming “Mayday” as you watched crypto markets puke from mid-April until the present. There was so much pain that momentum-chasing paper hands like proclaimed that they were “done” with crypto. As if – she will dutifully return posting crypto thirst traps once Bitcoin is back trending up and to the right in short order. Irene Zhao The price action played out as I expected. US tax season, consternation over what the Fed will do, the Bitcoin halving sell the news event, and a slowdown of US Bitcoin ETF asset under management (AUM) growth coalesced over the prior fortnight to produce a well-needed market cleansing. The tourists will sit out the next phase on the beach… if they can afford it. Us hard motherfuckers will hodl, and if possible, accumulate more of our favorite crypto reserve assets such as Bitcoin and Ether, and/or high-beta shitcoins like Solana, Dog Wif Hat, and dare I say Dogecoin (the OG doggie coin). This is not meant to be a fully fleshed-out global macroeconomics, politics, and crypto essay. Rather, I want to highlight why the US Treasury, Federal Reserve (Fed), and the Republic First Bank bailout provide fiat liquidity or a path to increased fiat liquidity now and into the near future. I will quickly step through a few tables that underpin my boooolishness. QT Taper = QE When the average muppet equates quantitative easing (QE) with printing money and inflation, it spells trouble for the elites. Therefore they need to change up the nomenclature and method of providing the junkie, that is, the fiat financial system, its hit of monetary heroin. Reducing the pace of asset runoff from the Fed’s balance in accordance with their quantitative tightening (QT) program sounds benign. But make no mistake – by reducing the rate of QT from $95 billion to $60 billion per month, the Fed is essentially adding $35 billion per month of dollar liquidity. When you combine the Interest on Reserve Balances, RRP payments, and interest payments on US Treasury debt, the reduction in QT increases the amount of stimulus provided to the global asset markets each month. The Fed announced this week that it would taper QT by the aforementioned amounts at its May 2024 meeting. Using a handy chart, let us examine the dollar liquidity situation before and after the meeting. Before Size of Facility Rate PA Monthly Amount (USD Bn) Interest Expense NA NA $88.27 IORB 3271.706 5.40% $14.72 RRP 438.148 5.30% $1.94 QT NA NA -$77.59 Total $27.34 Note that the QT line item is the actual monthly average taper amount in 2024 based on the . As you can see, the Fed has undershot the monthly target of $95 billion. It begs the question of whether the target is $60 billion per month and whether the Fed will undershoot that as well. Undershooting the target pace is positive for dollar liquidity. Fed’s weekly reported balance sheet After Size of Facility Rate PA Monthly Amount (USD Bn) Interest Expense NA NA $88.27 IORB 3271.706 5.40% $14.72 RRP 438.148 5.30% $1.94 QT NA NA -$60.00 Total $44.93 Increase in $ Liq per Month 64.32% “High” interest rates, which require the Fed and US Treasury to hand out interest payment stimmies to rich folks, coupled with a reduction in the pace of QT, are even more stimulative. Please read “ ” to understand what each line item means. Kite or Board That’s what beta cuck towel boy Powell is up to. What about his dominatrix, Bad Gurl Yellen? US Treasury Quarterly Refunding Announcement (QRA) Because the US is in the throes of fiscal dominance, Bad Gurl Yellen's pronouncements are more important than those of any other monetary official. Every quarter, the US Treasury publishes the QRA to guide the market as to the quantity and type of debt that must be issued to fund the government. Before the 2Q24 QRA, I had questions: Would Yellen be borrowing more or less than last quarter, and why? What is the maturity profile of the debt to be issued? What would be the target Treasury General Account (TGA) balance? Question 1: During the April – June 2024 quarter, Treasury expects to borrow $243 billion in privately-held net marketable debt, assuming an end-of-June cash balance of $750 billion. The borrowing estimate is $41 billion higher than announced in January 2024, largely due to lower cash receipts, partially offset by a higher beginning of-quarter cash balance. [2] [3] Source: QRA That’s no bueno if you are a holder of Treasuries. There will be more supply, and tax receipts were underwhelming despite the roaring US economy and stonk markets. This hastens the pace at which the bond market throws a fit and ratchets long-end rates markedly higher. Yellen’s response to that will be some form of yield curve control, and that’s when Bitcoin begins its ascent for realz to $1 million. Question 2: Given current fiscal forecasts, the Treasury Department expects to increase the 4-, 6-, and 8-week bill auction sizes in the coming days to ensure sufficient liquidity to meet our one-week cash needs around the end of May.  Then, in anticipation of the June 15th non-withheld and corporate tax date, Treasury expects to implement modest reductions to short-dated bill auction sizes during early to mid-June.  Subsequently, throughout July, the Treasury Department anticipates returning short-dated bill auction sizes to levels at or near the highs from February and March. Source: QRA Yellen needs to increase the issuance of short-dated bills because the market couldn’t handle it if she swung her BSD at the long end of the curve. The added benefit of issuing more bills is that it drains the RRP, which adds dollar liquidity to the system. To understand why, please read “ ”. Bad Gurl Question 3: During the July – September 2024 quarter, Treasury expects to borrow $847 billion in privately-held net marketable debt, assuming an end-of-September cash balance of $850 billion. Source: QRA The TGA balance target is $850 billion. It currently stands at $941 billion, which equates to a roughly $90 billion reduction over the next three months. To understand why, please read “ .” Bad Gurl The impact of this QRA is mildly dollar liquidity positive. It is not a bombshell like the November 2023 announcement, which sent bond, stonk, and crypto prices flying. But it will help pump our bags slowly over time. Republic First Bank Have you ever heard of this tiny, piece-of-shit bank? I hadn’t, until they went bust. The fact that another non-Too Big To Fail (TBTF) bank failed is not noteworthy. But what is important is the response of the monetary mandarins in charge of the Pax Americana. The US government (via the FDIC) insures deposits in any US bank up to $250,000. When a bank fails, uninsured depositors should get zeroed. However, that is politically unpalatable in an election year, especially if the powers that be have continuously assured the public the banking system is sound. Here is an excerpt from the : FDIC As of January 31, 2024, Republic Bank had approximately $6 billion in total assets and $4 billion in total deposits.  The FDIC estimates that the cost to the Deposit Insurance Fund (DIF) related to the failure of Republic Bank will be $667 million. The FDIC determined that compared to other alternatives, Fulton Bank’s acquisition of Republic Bank is the least costly resolution for the DIF, an insurance fund created by Congress in 1933 and managed by the FDIC to protect the deposits at the nation’s banks. Understanding what happened in plain speech requires reading between the lines. Fulton agreed to purchase Republic First and ensure all depositors were made whole only if the FDIC ponied up some cash. The FDIC insurance gave Fulton $667 million so that all Republic First depositors were made whole. Why is the insurance fund being used for all deposits when some deposits were not insured? The reason is that if all deposits weren’t covered, then a bank run would start. Any large depositor with a non-TBTF bank would instantly transfer money to a TBTF bank, which sport a full government guarantee of all deposits. Subsequently, thousands of banks would go under across the country. That is not a good look in a democratic republic with elections every two years. Once the public is educated that the bank failures are 100% due to Fed and US Treasury policy, some overpaid idiots will have to get real jobs. Rather than suffer at the ballot box, those in charge essentially now guarantee all deposits in the US banking system. That is a stealth addition of $6.7 trillion, as this is the amount of uninsured deposits as . reported by the St. Louis Fed This leads to money printing because the FDIC’s insurance fund doesn’t have $6.7 trillion. Maybe they need to ask CZ for advice because funds ain’t SAFU. Once the fund is exhausted, the FDIC will borrow money from the Fed, which will print money to satisfy the loan. Like the other stealth money printing policies discussed in this essay, there is no massive liquidity injection today. However, we now know with full confidence that trillions of contingent liabilities have been added to the Fed’s balance sheet, which will be funded with printed money. Buy in May, Go Away! The slow addition of billions of dollars of liquidity each month will dampen negative price movement from here on out. While I don’t expect crypto to fully realize the recent US monetary announcements' inflationary nature immediately, I expect prices to bottom, chop, and begin a slow grind higher. As the northern-hemispheric summer kicks into full gear, crypto muppets will be out enjoying being pre-rich at all the usual hot spots. I see you at DC10, Scorpios, Chiltern … I see you playa. I certainly won’t be babysitting Bitcoin when I could be two-stepping. The recent intense puke out provides an excellent opportunity to unstake my and spend synthetic dollars on high beta shitcoins. USDe I’m buying Solana and doggie coins for momentum trading positions. For longer-term shitcoin positions, I’m upping my allocations in Pendle* and will identify other tokens that are “on sale.” I will use the rest of May to increase my exposure. And then it’s time to set it, forget it, and wait for the market to appreciate the inflationary nature of the recent US monetary policy announcements. 同志们好 China is not to be forgotten. The CNY will be devalued, but it won’t be against USD; rather, it will be against gold and Bitcoin. I will explain this theory in an in-depth essay later this summer. For those of you who need bullet points on my predictions, here you go: Yes Did Bitcoin hit a local low at around $58,600 earlier this week? A rally to above $60,000 and then range-bound price action between $60,000 and $70,000 until August. What is your price prediction? Yes. Are the recent Fed and Treasury policy announcements stealth forms of money printing? Yachtzee!! Disclaimer: I am an advisor to and investor in Pendle, and have received Pendle tokens as compensation for my advisory services.

Mayday

মে দিবস

Maifeiertag

May Day

Au secours

मई दिवस

メーデー

노동절

Socorro

Первое мая

Mayıs günü

ngày tháng năm

劳动节

Introduction In developing large-scale systems, it is always essential to think about resilience. The load on an application typically varies over time based on the number of active users or the types of activities they are performing. One of the most common situations you will encounter sooner or later is server overload caused by unanticipated bursts in traffic. It happens because every server has functional limitations. That means the server has limited network and computational resources like CPU and memory, so the server can effectively handle only a certain number of requests. When the number of requests reaches some threshold and continues growing, it increases resource utilization, leading to higher latency and reducing availability. There are many strategies to handle that situation. For instance, you can run several instances of your application and use autoscaling to match the provisioned resources to the users's needs at any time. However, when the amount of traffic is incredibly huge, scaling out may take time, and may be overloaded or fail. I will discuss common strategies to prevent such a situation in this article. servers Causes leading to traffic spikes There may be many reasons leading to the sudden traffic spikes. Let's consider some of the common. An application can experience sudden spikes in traffic due to events like breaking news, product launches, or promotional campaigns. If the servers are not prepared to handle this surge of traffic, they can quickly become overloaded. Also, when the traffic to the application is dropped temporarily for some reason, the application scales down. Then, when the traffic returns, the application can't scale out fast, leading to server overload and even failure. Another common reason is that malicious bots, or malware, can flood a server with requests, effectively overwhelming its resources. It is known as a distributed denial-of-service (DDoS) attack. Strategies to prevent service overload There are two main strategies to prevent server overload: Throttling, Load shedding. Throttling controls the consumption of resources used by an instance of an application, an individual user, or an entire service. For example, a server experiencing high demand may start throttling requests, slowing them down, or rejecting them until the load subsides. It allows the system to handle the incoming traffic without crashing or becoming unresponsive. One common technique for throttling is rate limiting, which defines the maximum number of requests a user, a client, or an entire group can make within a specific time frame, ensuring no single client or user can monopolize system resources. It is a proactive measure that aims to prevent the system from reaching its capacity in the first place. For instance, a rate limiter may allow 100 requests from a given IP address per minute. Exceeding this limit could result in the user being temporarily blocked or having their requests queued until they are within the allowable rate. Load shedding is a more drastic technique. It involves intentionally dropping requests to prevent a server from becoming overloaded. It is only done as a last resort when other measures, such as rate limiting, have proven insufficient. By shedding requests from one application instance, the load can be redistributed to other application instances in the cluster, preventing any single instance from reaching its limits. An example of rate-limiting Several algorithms can be used to implement rate limiters. Here, let's consider a basic implementation of a rate limiter using a token bucket algorithm, where tokens are added to the bucket at a fixed rate. The request is allowed if a token is available when a request is made. Otherwise, it is denied. This implementation can be applied to throttling requests from particular users, IP addresses, API keys, or other groups of users. main.go package main

import (
	"fmt"
	"log"
	"net/http"
	"sync"
	"time"
)

type bucket struct {
	remainingTokens int
	lastRefillTime  time.Time
}

type RateLimiter struct {
	maxTokens      int
	refillInterval time.Duration
	buckets        map[string]*bucket
	mu             sync.Mutex
}

func NewRateLimiter(rate int, perInterval time.Duration) *RateLimiter {
	return &RateLimiter{
		maxTokens:      rate,
		refillInterval: perInterval,
		buckets:        make(map[string]*bucket),
	}
}

func (rl *RateLimiter) IsLimitReached(id string) bool {
	rl.mu.Lock()
	defer rl.mu.Unlock()

	b, ok := rl.buckets[id]

	// If the bucket doesn't exist, it is the first request for this client.
	// Create a new bucket and allow the request.
	if !ok {
		rl.buckets[id] = &bucket{
			remainingTokens: rl.maxTokens - 1,
			lastRefillTime:  time.Now(),
		}
		return false
	}

	// Calculate the number of tokens to add to the bucket since the last
	// request.
	refillInterval := int(time.Since(b.lastRefillTime) / rl.refillInterval)
	tokensAdded := rl.maxTokens * refillInterval
	currentTokens := b.remainingTokens + tokensAdded

	// There is no tokens to serve the request for this client.
	// Reject the request.
	if currentTokens < 1 {
		return true
	}

	if currentTokens > rl.maxTokens {
		// If the number of current tokens is greater than the maximum allowed,
		// then reset the bucket and decrease the number of tokens by 1.
		b.lastRefillTime = time.Now()
		b.remainingTokens = rl.maxTokens - 1
	} else {
		// Otherwise, update the bucket and decrease the number of tokens by 1.
		deltaTokens := currentTokens - b.remainingTokens
		deltaRefills := deltaTokens / rl.maxTokens
		deltaTime := time.Duration(deltaRefills) * rl.refillInterval
		b.lastRefillTime = b.lastRefillTime.Add(deltaTime)
		b.remainingTokens = currentTokens - 1
	}

	// Allow the request.
	return false
}

type Handler struct {
	rl *RateLimiter
}

func NewHandler(rl *RateLimiter) *Handler {
	return &Handler{rl: rl}
}

func (h *Handler) Handler(w http.ResponseWriter, r *http.Request) {
	// Here should be the logic to get the client ID from the request 
	// (it could be a user ID, an IP address, an API key, etc.)
	clientID := "some-client-id"
	if h.rl.IsLimitReached(clientID) {
		w.WriteHeader(http.StatusTooManyRequests)
		fmt.Fprint(w, http.StatusText(http.StatusTooManyRequests))
		return
	}

	w.WriteHeader(http.StatusOK)
	fmt.Fprint(w, http.StatusText(http.StatusOK))
}

func main() {
	// We allow 1000 requests per second per client to our service.
	rl := NewRateLimiter(1000, 1*time.Second)
	h := NewHandler(rl)
	http.HandleFunc("/", h.Handler)
	log.Fatal(http.ListenAndServe(":8080", nil))
} Let's run our example using Docker Compose with configured for a container. Also, we will use , a benchmarking tool, to check how our application works on different loads. We will use the following and : resource constraints bombardier Dockerfile docker-compose.yml Dockerfile FROM golang:1.21 AS build-stage
WORKDIR /code
COPY main.go ./
RUN CGO_ENABLED=0 GOOS=linux go build -o /service main.go
FROM gcr.io/distroless/base AS build-release-stage
WORKDIR /
COPY --from=build-stage /service /service
EXPOSE 8080
ENTRYPOINT ["/service"] docker-compose.yml services:
  rate_limiting:
    build: .
    ports:
      - "8080:8080"
    deploy:
      resources:
        limits:
          cpus: '.20'
          memory: 100M
        reservations:
          cpus: '0.10'
          memory: 50M Let's run our application using the following command: docker compose -f ./cmd/rate_limiting/docker-compose.yml up --build --force-recreate -d You can monitor the container resource usage using the following command: dcocker stats Let's run the bombardier with different settings and check the results in a separate terminal window. First, let's try sending 10000 requests with one concurrent connection. $ bombardier -c 1 -n 10000 http://127.0.0.1:8080/
Bombarding http://127.0.0.1:8080/ with 10000 request(s) using 1 connection(s)
 10000 / 10000 [===============================================================] 100.00% 859/s 11s
Done!
Statistics        Avg      Stdev        Max
  Reqs/sec       868.33     833.53    2684.45
  Latency        1.15ms     6.93ms    75.42ms
  HTTP codes:
    1xx - 0, 2xx - 10000, 3xx - 0, 4xx - 0, 5xx - 0
    others - 0
  Throughput:   151.93KB/s From the results, you can see that the request rate on average is less than 1000 requests per second, which is the maximum allowed rate, and all requests were processed successfully. Next,  let's try sending 10000 requests with 100 concurrent connections. $ bombardier -c 100 -n 10000 http://127.0.0.1:8080/
Bombarding http://127.0.0.1:8080/ with 10000 request(s) using 100 connection(s)
 10000 / 10000 [===============================================================] 100.00% 3320/s 3s
Done!
Statistics        Avg      Stdev        Max
  Reqs/sec      3395.87    6984.32   32322.59
  Latency       28.02ms    37.61ms   196.95ms
  HTTP codes:
    1xx - 0, 2xx - 3000, 3xx - 0, 4xx - 7000, 5xx - 0
    others - 0
  Throughput:   675.35KB/s You can see that the server started to return HTTP 429 status code, which means the server is overloaded due to many requests. Clean up your environment using the following command after all tests are done: docker compose -f ./cmd/rate_limiting/docker-compose.yml down --remove-orphans --timeout 1 --volumes An example of load-shedding Depending on your particular case, you can use different approaches to load shedding: Dropping random requests when the system becomes overloaded, Using a load balancer to distribute the load evenly, Monitoring server load continuously and dropping or rejecting requests when a certain load level is reached, Monitoring system metrics like CPU utilization, network I/O, or memory usage and dropping requests when these metrics reach certain thresholds, Set up priority levels for requests and start refusing low-priority requests when the system is under load, Etc. Load shedding can be implemented at various levels, including load balancers, servers, and software libraries. It requires careful planning and implementation, as poorly implemented load shedding can result in important requests being dropped, causing a negative impact on user experience or system functionality. Let's implement a simple load-shedding mechanism by detecting request overload conditions and responding with an HTTP 503 status code. main .go package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"sync/atomic"
	"time"
)

type LoadShedder struct {
	isOverloaded atomic.Bool
}

func NewLoadShedder(ctx context.Context, checkInterval, overloadFactor time.Duration) *LoadShedder {
	ls := LoadShedder{}

	go ls.runOverloadDetector(ctx, checkInterval, overloadFactor)

	return &ls
}

func (ls *LoadShedder) runOverloadDetector(ctx context.Context, checkInterval, overloadFactor time.Duration) {
	ticker := time.NewTicker(checkInterval)
	defer ticker.Stop()

	// Start with a fresh start time.
	startTime := time.Now()
	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			// Check how long it took to process the last batch of requests.
			elapsed := time.Since(startTime)
			if elapsed > overloadFactor {
				// If it took longer than the overload factor, we're overloaded.
				ls.isOverloaded.Store(true)
			} else {
				// Otherwise, we're not overloaded.
				ls.isOverloaded.Store(false)
			}
			// Reset the start time.
			startTime = time.Now()
		}
	}
}

func (ls *LoadShedder) IsOverloaded() bool {
	return ls.isOverloaded.Load()
}

type Handler struct {
	ls *LoadShedder
}

func NewHandler(ls *LoadShedder) *Handler {
	return &Handler{ls: ls}
}

func (h *Handler) Handler(w http.ResponseWriter, r *http.Request) {
	if h.ls.IsOverloaded() {
		w.WriteHeader(http.StatusServiceUnavailable)
		fmt.Fprint(w, http.StatusText(http.StatusServiceUnavailable))
		return
	}

	w.WriteHeader(http.StatusOK)
	fmt.Fprint(w, http.StatusText(http.StatusOK))
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// The load shedder will check every 100ms if the last batch of requests
	// took longer than 200ms.
	ls := NewLoadShedder(ctx, 100*time.Millisecond, 200*time.Millisecond)

	h := NewHandler(ls)
	http.HandleFunc("/", h.Handler)

	log.Fatal(http.ListenAndServe(":8080", nil))
} We define the struct to run the load detector used in our request handler to check if we should return the HTTP 503 status code or process the request. The struct has an atomic flag indicating if the system is overloaded. We use atomic boolean value to make it thread-safe. We also have the method that returns the current value of the flag. In the function, we create a new and run the overload detector in a goroutine that checks according to the specified interval if the system is overloaded based on the overload factor. We check how much time has passed since the last check. If it is higher than the overload factor, the system is overloaded. That means that our request handler used resources for too long, and we need more capacity to handle the requests. LoadShedder LoadShedder IsOverloaded NewLoadShedder LoadShedder Let's run our example using. We will use the following and : Dockerfile docker-compose.yml Dockerfile FROM golang:1.21 AS build-stage
WORKDIR /code
COPY main.go ./
RUN CGO_ENABLED=0 GOOS=linux go build -o /service main.go
FROM gcr.io/distroless/base AS build-release-stage
WORKDIR /
COPY --from=build-stage /service /service
EXPOSE 8080
ENTRYPOINT ["/service"] docker-compose.yml services:
  load_shedding:
    build: .
    ports:
      - "8080:8080"
    deploy:
      resources:
        limits:
          cpus: '.20'
          memory: 100M
        reservations:
          cpus: '0.10'
          memory: 50M Let's run our application using the following command: docker compose -f ./cmd/load_shedding/docker-compose.yml up --build --force-recreate -d You can monitor the container resource usage using the following command: dcocker stats Let's run the bombardier with different settings and check the results in a separate terminal window. First, let's try sending 10000 requests with 10 concurrent connections. $ bombardier -c 10 -n 10000 http://127.0.0.1:8080/
Bombarding http://127.0.0.1:8080/ with 10000 request(s) using 10 connection(s)
 10000 / 10000 [===============================================================] 100.00% 1346/s 7s
Done!
Statistics        Avg      Stdev        Max
  Reqs/sec      1389.49    1582.00    6284.42
  Latency        7.24ms    22.41ms    98.43ms
  HTTP codes:
    1xx - 0, 2xx - 10000, 3xx - 0, 4xx - 0, 5xx - 0
    others - 0
  Throughput:   242.78KB/s The results show that the maximum latency is less than 100 ms, and all requests were processed successfully. Next, let's try sending 10000 requests with 1000 concurrent connections. $ bombardier -c 1000 -n 10000 http://127.0.0.1:8080/
Bombarding http://127.0.0.1:8080/ with 10000 request(s) using 1000 connection(s)
 10000 / 10000 [===============================================================] 100.00% 3791/s 2s
Done!
Statistics        Avg      Stdev        Max
  Reqs/sec      4242.28   11985.30   58592.64
  Latency      211.67ms   210.89ms      1.54s
  HTTP codes:
    1xx - 0, 2xx - 8823, 3xx - 0, 4xx - 0, 5xx - 1177
    others - 0
  Throughput:   696.96KB/s You can see that the server started to return HTTP 503 status code, which means the server is overloaded due to many requests, and you can see the maximum latency is more than 1 second. Clean up your environment using the following command after all tests are done: docker compose -f ./cmd/load_shedding/docker-compose.yml down --remove-orphans --timeout 1 --volumes Conclusion In this article, we discussed the causes leading to traffic spikes and strategies to prevent server overload. We also implemented a simple rate limiter and load shedder to demonstrate how they work. You can find all the code from the article here . https://github.com/ivanlemeshev/resilience For the production environment, you can use ready-to-use rate limiters like or . https://pkg.go.dev/golang.org/x/time/rate https://github.com/uber-go/ratelimit

How To Prevent Server Overload In Go

A Journey to the Center of the Earth by Jules Verne, is part of the HackerNoon Books Series. You can jump to any chapter in this book . WE CONTINUE OUR DESCENT here CHAPTER XV - WE CONTINUE OUR DESCENT At eight o'clock the next morning, a faint kind of dawn of day awoke us. The thousand and one prisms of the lava collected the light as it passed and brought it to us like a shower of sparks. We were able with ease to see objects around us. "Well, Harry, my boy," cried the delighted Professor, rubbing his hands together, "what say you now? Did you ever pass a more tranquil night in our house in the Konigstrasse? No deafening sounds of cart wheels, no cries of hawkers, no bad language from boatmen or watermen!" "Well, Uncle, we are quite at the bottom of this well—but to me there is something terrible in this calm." "Why," said the Professor hotly, "one would say you were already beginning to be afraid. How will you get on presently? Do you know, that as yet, we have not penetrated one inch into the bowels of the earth." "What can you mean, sir?" was my bewildered and astonished reply. "I mean to say that we have only just reached the soil of the island itself. This long vertical tube, which ends at the bottom of the crater of Sneffels, ceases here just about on a level with the sea." "Are you sure, sir?" "Quite sure. Consult the barometer." It was quite true that the mercury, after rising gradually in the instrument, as long as our descent was taking place, had stopped precisely at twenty-nine degrees. "You perceive," said the Professor, "we have as yet only to endure the pressure of air. I am curious to replace the barometer by the manometer." The barometer, in fact, was about to become useless—as soon as the weight of the air was greater than what was calculated as above the level of the ocean. "But," said I, "is it not very much to be feared that this ever-increasing pressure may not in the end turn out very painful and inconvenient?" "No," said he. "We shall descend very slowly, and our lungs will be gradually accustomed to breathe compressed air. It is well known that aeronauts have gone so high as to be nearly without air at all—why, then, should we not accustom ourselves to breathe when we have, say, a little too much of it? For myself, I am certain I shall prefer it. Let us not lose a moment. Where is the packet which preceded us in our descent?" I smilingly pointed it out to my uncle. Hans had not seen it, and believed it caught somewhere above us: "Huppe" as he phrased it. "Now," said my uncle, "let us breakfast, and break fast like people who have a long day's work before them." Biscuit and dried meat, washed down by some mouthfuls of water flavored with Schiedam, was the material of our luxurious meal. As soon as it was finished, my uncle took from his pocket a notebook destined to be filled by memoranda of our travels. He had already placed his instruments in order, and this is what he wrote: Monday, June 29th Chronometer, 8h. 17m. morning. Barometer, 29.6 inches. Thermometer, 6 degrees [43 degrees Fahr.] Direction, E.S.E. This last observation referred to the obscure gallery, and was indicated to us by the compass. "Now, Harry," cried the Professor, in an enthusiastic tone of voice, "we are truly about to take our first step into the Interior of the Earth; never before visited by man since the first creation of the world. You may consider, therefore, that at this precise moment our travels really commence." As my uncle made this remark, he took in one hand the Ruhmkorff coil apparatus, which hung round his neck, and with the other he put the electric current into communication with the worm of the lantern. And a bright light at once illumined that dark and gloomy tunnel! The effect was magical! Hans, who carried the second apparatus, had it also put into operation. This ingenious application of electricity to practical purposes enabled us to move along by the light of an artificial day, amid even the flow of the most inflammable and combustible gases. "Forward!" cried my uncle. Each took up his burden. Hans went first, my uncle followed, and I going third, we entered the somber gallery! Just as we were about to engulf ourselves in this dismal passage, I lifted up my head, and through the tubelike shaft saw that Iceland sky I was never to see again! Was it the last I should ever see of any sky? The stream of lava flowing from the bowels of the earth in 1219 had forced itself a passage through the tunnel. It lined the whole of the inside with its thick and brilliant coating. The electric light added very greatly to the brilliancy of the effect. The great difficulty of our journey now began. How were we to prevent ourselves from slipping down the steeply inclined plane? Happily some cracks, abrasures of the soil, and other irregularities, served the place of steps; and we descended slowly; allowing our heavy luggage to slip on before, at the end of a long cord. But that which served as steps under our feet became in other places stalactites. The lava, very porous in certain places, took the form of little round blisters. Crystals of opaque quartz, adorned with limpid drops of natural glass suspended to the roof like lusters, seemed to take fire as we passed beneath them. One would have fancied that the genii of romance were illuminating their underground palaces to receive the sons of men. "Magnificent, glorious!" I cried in a moment of involuntary enthusiasm, "What a spectacle, Uncle! Do you not admire these variegated shades of lava, which run through a whole series of colors, from reddish brown to pale yellow—by the most insensible degrees? And these crystals, they appear like luminous globes." "You are beginning to see the charms of travel, Master Harry," cried my uncle. "Wait a bit, until we advance farther. What we have as yet discovered is nothing—onwards, my boy, onwards!" It would have been a far more correct and appropriate expression, had he said, "let us slide," for we were going down an inclined plane with perfect ease. The compass indicated that we were moving in a southeasterly direction. The flow of lava had never turned to the right or the left. It had the inflexibility of a straight line. Nevertheless, to my surprise, we found no perceptible increase in heat. This proved the theories of Humphry Davy to be founded on truth, and more than once I found myself examining the thermometer in silent astonishment. Two hours after our departure it only marked fifty-four degrees Fahrenheit. I had every reason to believe from this that our descent was far more horizontal than vertical. As for discovering the exact depth to which we had attained, nothing could be easier. The Professor as he advanced measured the angles of deviation and inclination; but he kept the result of his observations to himself. About eight o'clock in the evening, my uncle gave the signal for halting. Hans seated himself on the ground. The lamps were hung to fissures in the lava rock. We were now in a large cavern where air was not wanting. On the contrary, it abounded. What could be the cause of this—to what atmospheric agitation could be ascribed this draught? But this was a question which I did not care to discuss just then. Fatigue and hunger made me incapable of reasoning. An unceasing march of seven hours had not been kept up without great exhaustion. I was really and truly worn out; and delighted enough I was to hear the word Halt. Hans laid out some provisions on a lump of lava, and we each supped with keen relish. One thing, however, caused us great uneasiness—our water reserve was already half exhausted. My uncle had full confidence in finding subterranean resources, but hitherto we had completely failed in so doing. I could not help calling my uncle's attention to the circumstance. "And you are surprised at this total absence of springs?" he said. "Doubtless—I am very uneasy on the point. We have certainly not enough water to last us five days." "Be quite easy on that matter," continued my uncle. "I answer for it we shall find plenty of water—in fact, far more than we shall want." "But when?" "When we once get through this crust of lava. How can you expect springs to force their way through these solid stone walls?" "But what is there to prove that this concrete mass of lava does not extend to the centre of the earth? I don't think we have as yet done much in a vertical way." "What puts that into your head, my boy?" asked my uncle mildly. "Well, it appears to me that if we had descended very far below the level of the sea—we should find it rather hotter than we have." "According to your system," said my uncle; "but what does the thermometer say?" "Scarcely fifteen degrees by Reaumur, which is only an increase of nine since our departure." "Well, and what conclusion does that bring you to?" inquired the Professor. "The deduction I draw from this is very simple. According to the most exact observations, the augmentation of the temperature of the interior of the earth is one degree for every hundred feet. But certain local causes may considerably modify this figure. Thus at Yakoust in Siberia, it has been remarked that the heat increases a degree every thirty-six feet. The difference evidently depends on the conductibility of certain rocks. In the neighborhood of an extinct volcano, it has been remarked that the elevation of temperature was only one degree in every five-and-twenty feet. Let us, then, go upon this calculation—which is the most favorable—and calculate." "Calculate away, my boy." "Nothing easier," said I, pulling out my notebook and pencil. "Nine times one hundred and twenty-five feet make a depth of eleven hundred and twenty-five feet." "Archimedes could not have spoken more geometrically." "Well?" "Well, according to my observations, we are at least ten thousand feet below the level of the sea." "Can it be possible?" "Either my calculation is correct, or there is no truth in figures." The calculations of the Professor were perfectly correct. We were already six thousand feet deeper down in the bowels of the earth than anyone had ever been before. The lowest known depth to which man had hitherto penetrated was in the mines of Kitzbuhel, in the Tirol, and those of Wurttemberg. The temperature, which should have been eighty-one, was in this place only fifteen. This was a matter for serious consideration. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Jules Verne (2006). A Journey to the Center of the Earth. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/files/18857/18857-h/18857-h.htm This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

WE CONTINUE OUR DESCENT

In this article, we'll explore common pitfalls and potential solutions when working with (using ts-node) in Development Pipelines. This piece is particularly valuable for developers encountering problems during the deployment process, often characterized by obscure error messages and puzzling behavior. We'll take a practical, step-by-step approach, investigating these issues, delving into their root causes, and outlining strategies for fixing them. TypeScript Azure Serverless Whether you're a seasoned developer, DevOps engineer, or a curious beginner eager to learn more about TypeScript and Azure DevOps, this comprehensive guide will serve as a valuable tool in navigating the intricacies of ts-node deployments in Azure pipelines. Problem Working on and building our backend system on different cloud solutions ( , Azure) our team has faced several issues on serverless deployment. Restart GCP Using as a runtime in-memory with the latest TypeScript 5.0.4 and nodejs18, we got errors after successfully building our app using dev.azure.com pipelines (Image 1). ts-node ts-js compiler The errors during app startup: 2023-05-25T10:52:24.326355260Z    _____
2023-05-25T10:52:24.326400861Z   /  _  \ __________ _________   ____
2023-05-25T10:52:24.326406761Z  /  /_\  \\___   /  |  \_  __ \_/ __ \
2023-05-25T10:52:24.326410361Z /    |    \/    /|  |  /|  | \/\  ___/
2023-05-25T10:52:24.326413761Z \____|__  /_____ \____/ |__|    \___  >
2023-05-25T10:52:24.326417661Z         \/      \/                  \/
2023-05-25T10:52:24.326420961Z A P P   S E R V I C E   O N   L I N U X
2023-05-25T10:52:24.326424361Z
2023-05-25T10:52:24.326427461Z Documentation: http://aka.ms/webapp-linux
2023-05-25T10:52:24.326430661Z NodeJS quickstart: https://aka.ms/node-qs
2023-05-25T10:52:24.326433761Z NodeJS Version : v18.16.0
2023-05-25T10:52:24.326436961Z Note: Any data outside '/home' is not persisted
2023-05-25T10:52:24.326440161Z
2023-05-25T10:52:26.504451955Z Starting OpenBSD Secure Shell server: sshd.
2023-05-25T10:52:26.807519399Z Starting periodic command scheduler: cron.
2023-05-25T10:52:26.863716274Z Cound not find build manifest file at '/home/site/wwwroot/oryx-manifest.toml'
2023-05-25T10:52:26.866811884Z Could not find operation ID in manifest. Generating an operation id...
2023-05-25T10:52:26.868247288Z Build Operation ID: 796ee1ba-542e-43f1-9f6c-1e7a5e2e9815
2023-05-25T10:52:27.139574733Z Environment Variables for Application Insight's IPA Codeless Configuration exists..
2023-05-25T10:52:27.156085084Z Writing output script to '/opt/startup/startup.sh'
2023-05-25T10:52:27.229878114Z Running #!/bin/sh
2023-05-25T10:52:27.229938514Z
2023-05-25T10:52:27.229945514Z # Enter the source directory to make sure the script runs where the user expects
2023-05-25T10:52:27.229950214Z cd "/home/site/wwwroot"
2023-05-25T10:52:27.229954114Z
2023-05-25T10:52:27.229957814Z export NODE_PATH=/usr/local/lib/node_modules:$NODE_PATH
2023-05-25T10:52:27.229979514Z if [ -z "$PORT" ]; then
2023-05-25T10:52:27.230057715Z 		export PORT=8080
2023-05-25T10:52:27.230063815Z fi
2023-05-25T10:52:27.230067915Z
2023-05-25T10:52:27.246143265Z PATH="$PATH:/home/site/wwwroot" yarn start
2023-05-25T10:52:30.491250324Z yarn run v1.17.3
2023-05-25T10:52:30.896237571Z $ ts-node src/app.ts
2023-05-25T10:52:31.521499168Z node:internal/modules/cjs/loader:1078
2023-05-25T10:52:31.577313557Z   throw err;
2023-05-25T10:52:31.577384758Z   ^
2023-05-25T10:52:31.577391958Z
2023-05-25T10:52:31.577396558Z Error: Cannot find module './util'
2023-05-25T10:52:31.577400858Z Require stack:
2023-05-25T10:52:31.577404958Z - /home/site/wwwroot/node_modules/.bin/ts-node
2023-05-25T10:52:31.577484858Z     at Module._resolveFilename (node:internal/modules/cjs/loader:1075:15)
2023-05-25T10:52:31.577494058Z     at Module._load (node:internal/modules/cjs/loader:920:27)
2023-05-25T10:52:31.577498458Z     at Module.require (node:internal/modules/cjs/loader:1141:19)
2023-05-25T10:52:31.577502658Z     at require (node:internal/modules/cjs/helpers:110:18)
2023-05-25T10:52:31.577506858Z     at Object.<anonymous> (/home/site/wwwroot/node_modules/.bin/ts-node:9:16)
2023-05-25T10:52:31.577511558Z     at Module._compile (node:internal/modules/cjs/loader:1254:14)
2023-05-25T10:52:31.577551858Z     at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)
2023-05-25T10:52:31.577557158Z     at Module.load (node:internal/modules/cjs/loader:1117:32)
2023-05-25T10:52:31.577561358Z     at Module._load (node:internal/modules/cjs/loader:958:12)
2023-05-25T10:52:31.577565458Z     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12) {
2023-05-25T10:52:31.577569658Z   code: 'MODULE_NOT_FOUND',
2023-05-25T10:52:31.577573658Z   requireStack: [ '/home/site/wwwroot/node_modules/.bin/ts-node' ]
2023-05-25T10:52:31.577577758Z }
2023-05-25T10:52:31.577586558Z
2023-05-25T10:52:31.577591058Z Node.js v18.16.0
2023-05-25T10:52:31.684203528Z error Command failed with exit code 1. The key points of these logs are: Error: Cannot find module './util' /home/site/wwwroot/node_modules/.bin/ts-node requireStack: [ '/home/site/wwwroot/node_modules/.bin/ts-node' ] error Command failed with exit code 1. Spending hours of googling and searching for similar problems on Stack Overflow, we cannot define the nature of the issue. Trying different pipeline setups, and switching from Linux based web app to Windows does not help. The same code works fine in the case of serverless Google Cloud, but for some reason does not work on serverless Azure. Finally, we got a solution: We switch to a basic compiler and everything worked fine. “ts-node” “tsc“ In this article, I will explain some details of switching your existing project, that uses to a native compiler. ts-node tsc Tiny ts-node project First, we need a basic project that has only one file and ts-node on it (Image 2). The folder contains our app.ts file: src import * as http from 'http';

const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Hello Hackernoon. We are using ts on Azure!\n');
});

server.listen(8080, '0.0.0.0', () => {
    console.log('Server running at http://0.0.0.0:8080/');
}); In we have added folder and because compiling from to will be inside the Azure pipeline process. .gitignore dist node_modules ts js The content of package.json: {
  "name": "ts-nodejs",
  "version": "1.0.0",
  "description": "",
  "scripts": {
    "start": "ts-node src/app.ts"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "ts-node": "^10.9.1",
    "typescript": "^5.0.4"
  },
  "devDependencies": {
    "@types/node": "^20.2.3"
  }
} We have installed only ts-node and typescript packages. First, we need to modify the start command and create a new command and add it here: {
  "name": "tsc-nodejs",
  "version": "1.0.0",
  "description": "",
  "scripts": {
    "start": "node dist/app.js",
    "build": "tsc"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "ts-node": "^10.9.1",
    "typescript": "^5.0.4"
  },
  "devDependencies": {
    "@types/node": "^20.2.3"
  }
} All project pre-compiled files will be stored in the folder, which will execute our entry point of the app (app.js). the command executes or compiler. It gets settings from file. dist nodejs Build tsc tsconfig.json Our settings will be: {
  "compilerOptions": {
    "target": "ES2019",
    "module": "commonjs",
    "esModuleInterop": true,
    "allowUnreachableCode": false,
    "allowUnusedLabels": false,
    "noFallthroughCasesInSwitch": true,
    "noImplicitAny": false,
    "noImplicitReturns": true,
    "noImplicitThis": true,
    "noUnusedLocals": true,
    "strictBindCallApply": true,
    "strictFunctionTypes": true,
    "strictNullChecks": true,
    "strictPropertyInitialization": true,
    "removeComments": true,
    "strict": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "dist",
    "baseUrl": "./src",
    "rootDir": "src",
    "paths": {
      "@extensions/*": ["handlers/extensions/*"],
      "@services/*": ["services/*"],
      "@docs/*": ["docs/*"],
      "@server/*": ["server/*"],
      "@handlers/*": ["handlers/*"],
      "@app/*": ["*"],
    },
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "typeRoots": [
      "./types",
      "./node_modules/@types"
    ],
    "allowSyntheticDefaultImports": true,
    "lib": ["es5", "es6", "dom"],
    "moduleResolution": "node",
  },
  "include": [
    "**/*"
  ],
  "exclude": [
    "dist",
    "node_modules"
  ]
} The most important parts of the tsconfig.json: "noEmit": false,
 "include": [
    "**/*"
  ],
"outDir": "dist",
"baseUrl": "./src",
"rootDir": "src", Be sure, that is false (by default is false), is the name of the folder, where will save precompiled files, and is , where your project is (don’t save project files outside folder, because will ignore them). noEmit outDir tsc baseUrl rootDir src src tsc In this example, I also have added in case you have it on an existing project, but this tiny project does not use its allies, so you can ignore them. If you use allies on your project, please change them inside from: paths package.json "_moduleAliases": {
    "@extensions": "src/handlers/extensions",
    "@services": "src/services",
    "@docs": "src/docs",
    "@server": "src/server",
    "@handlers": "src/handlers",
    "@app": "src"
  } to this: "_moduleAliases": {
    "@extensions": "dist/handlers/extensions",
    "@services": "dist/services",
    "@docs": "dist/docs",
    "@server": "dist/server",
    "@handlers": "dist/handlers",
    "@app": "dist"
  } Finally, you need to change basic config from: azure-pipelines.yaml # Node.js Express Web App to Linux on Azure
# Build a Node.js Express app and deploy it to Azure as a Linux web app.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- master

variables:

  # Azure Resource Manager connection created during pipeline creation
  azureSubscription: '<Your sub>'

  # Web app name
  webAppName: '<Your webAppName>'

  # Environment name
  environmentName: 'Your webAppName>'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: Build
    displayName: Build
    pool:
      vmImage: $(vmImageName)

    steps:
    - task: NodeTool@0
      inputs:
        versionSpec: '18.x'
      displayName: 'Install Node.js'

    - script: |
        npm install yarn
        yarn
      displayName: 'npm install, build and test'

    - task: ArchiveFiles@2
      displayName: 'Archive files'
      inputs:
        rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
        includeRootFolder: false
        archiveType: zip
        archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
        replaceExistingArchive: true

    - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
      artifact: drop

- stage: Deploy
  displayName: Deploy stage
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: Deploy
    displayName: Deploy
    environment: $(environmentName)
    pool:
      vmImage: $(vmImageName)
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            displayName: 'Azure Web App Deploy: Your webAppName>'
            inputs:
              azureSubscription: $(azureSubscription)
              appType: webAppLinux
              appName: $(webAppName)
              runtimeStack: 'NODE|18-lts'
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
              startUpCommand: 'yarn start' to this: # Node.js Express Web App to Linux on Azure
# Build a Node.js Express app and deploy it to Azure as a Linux web app.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- master

variables:

  # Azure Resource Manager connection created during pipeline creation
  azureSubscription: 'Your sub'

  # Web app name
  webAppName: 'Your webAppName>'

  # Environment name
  environmentName: 'Your webAppName>'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: Build
    displayName: Build
    pool:
      vmImage: $(vmImageName)

    steps:
    - task: NodeTool@0
      inputs:
        versionSpec: '18.x'
      displayName: 'Install Node.js'

    - script: |
        npm install yarn
        yarn
        yarn build
      displayName: 'npm install, build and test'

    - task: ArchiveFiles@2
      displayName: 'Archive files'
      inputs:
        rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
        includeRootFolder: false
        archiveType: zip
        archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
        replaceExistingArchive: true

    - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
      artifact: drop

- stage: Deploy
  displayName: Deploy stage
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: Deploy
    displayName: Deploy
    environment: $(environmentName)
    pool:
      vmImage: $(vmImageName)
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            displayName: 'Azure Web App Deploy: Your webAppName>'
            inputs:
              azureSubscription: $(azureSubscription)
              appType: webAppLinux
              appName: $(webAppName)
              runtimeStack: 'NODE|18-lts'
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
              startUpCommand: 'yarn start' Finally, and see what will happen! git push Conclusion Hope this article will save a lot of time during debugging process in case of using with . It's clear that the complexities of TypeScript deployments within Azure DevOps pipelines can present unique challenges. However, by taking a systematic approach and learning to understand the underpinnings of ts-node and Azure pipelines, we can effectively troubleshoot and resolve these obstacles. ts-node Azure Node.js Serverless Apps In this article, we dove into the most common issues developers encounter, broke down the intricacies of these problems, and provided step-by-step solutions. Remember, it's not about avoiding problems altogether – it's about developing the ability to diagnose, troubleshoot, and solve them effectively when they inevitably arise. Moving forward, take this knowledge and apply it to your DevOps processes. Not only will you increase your productivity, but you'll also be contributing to a smoother, more efficient pipeline for your entire team. There's always more to learn in this ever-evolving field, and this guide is just one step towards mastering Azure DevOps with TypeScript. Stay curious, keep learning, and happy coding!

Resolving Deployment Issues with Ts-node and Azure Development Pipelines

Hello, software adventurers! Today, we'll be embarking on a new journey — a journey where you'll learn how to set up a pipeline to deploy serverless Node.js applications on Azure. If you're new to software development, fear not! This article is specially tailored to provide you with a gentle, yet comprehensive, introduction to this exciting area of . cloud computing With the rise of cloud computing, the concept of serverless computing has become more prominent. The term "serverless" doesn't mean there are no servers, but rather that you don't have to manage them. Essentially, it enables you to focus more on writing code and less on infrastructure management. is a top-tier cloud services provider that offers a robust platform for serverless applications. In this guide, we'll be using Azure Functions, a serverless computing service that lets you run event-triggered code without having to provision or manage infrastructure. Microsoft Azure Article Content Setting Up Azure Account Creating A Web App Resource Creating Node.js Application Setting Up Azure DevOps Project Configuring Azure Pipeline Deploying Your Serverless Application Let's dive in and start exploring these sections one by one. Setting Up Azure Account Before we can deploy anything, we first need to create an Azure account. If you haven't done this before, follow these steps: Visit the Azure portal at . https://portal.azure.com Click on . "Create a free account" Fill in your details and follow the prompts. After all, you'll get in Azure credits and free access to popular services for 12 months. $200 Creating A Web App Resource The comprehensive procedure was covered in . Our goal is to establish a fully operational web application server, serving as a bridge between our deployment pipeline on dev.azure.com and the previously created web application. Consequently, every change in the branch will trigger an automatic deployment of our web application. another article Creating a Node.js Application To create a "Hello World" application in Node.js, follow these steps: Install Node.js If you don't have Node.js installed on your computer, you can download it from . , the latest LTS version of Node.js is 18. Follow the instructions on the website to install it. https://nodejs.org/ Setup Your Project Create a new directory on your computer where you want your project to reside. Open a terminal or command prompt, navigate to your newly created directory, and initiate a new Node.js project by typing the following command: npm init -y The command creates a new file in your directory with default values. The file is used to manage the dependencies of your Node.js project. npm init -y package.json package.json Create a New JavaScript File In the same directory, create a new JavaScript file. You can name it anything you like, but for this example, let's call it . app.js Write the "Hello World" Code Open file in your preferred text editor and enter the following code: app.js const http = require('http');

const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Hello World\n');
});

server.listen(8080, '0.0.0.0', () => {
    console.log('Server running at http://0.0.0.0:8080/');
}); Also, you need to change the file to run in on Azure: package.json {
  "name": "hackernoon",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
} Setting Up Azure DevOps Project After creating your Azure account and Node.js application, the next step is to create an Azure DevOps project: Go to the Azure DevOps portal at . https://dev.azure.com Log in with your Azure account. Click on and provide a name and description for the project. "New project" Configuring Azure Pipeline To set up your automatic deploy pipeline, you need to store the project code somewhere. We need to upload our project to the private Azure git repo (Image 1). Using you should upload your code to Azure Repos. Some commands that I have used (inside the project folder I have opened cmd.exe and wrote these commands) git git init
git remote add origin https://<your_name>/<Your name>/hackernoon/_git/hackernoon
git add .
git commit -m "initial"
git push --set-upstream origin master After doing this, your code will be on Azure Cloud. Next step, you should click on the button (Image 2). “Pipelines“ Then . Choose (Image 3), then choose Node.js App for Linux (Image 4). “Create Pipeline” “Azure Repos Git“ Then the process will ask you to get access to your subscription plan and after all, you will see your Web App name, which you have created earlier (Image 5). Finally, Azure will create a file for us. We need to change some parameters. yaml # Node.js Express Web App to Linux on Azure
# Build a Node.js Express app and deploy it to Azure as a Linux web app.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- master

variables:

  # Azure Resource Manager connection created during pipeline creation
  azureSubscription: '<Your sub>'

  # Web app name
  webAppName: '<Your name>'

  # Environment name
  environmentName: 'Your name'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: Build
    displayName: Build
    pool:
      vmImage: $(vmImageName)

    steps:
    - task: NodeTool@0
      inputs:
        # change this "versionSpec: '10.x' to versionSpec: '18.x'
      displayName: 'Install Node.js'

    - script: |
        npm install
        # Delete this "npm run build --if-present"
        # Delete this "npm run test --if-present"
      displayName: 'npm install, build and test'

    - task: ArchiveFiles@2
      displayName: 'Archive files'
      inputs:
        rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
        includeRootFolder: false
        archiveType: zip
        archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
        replaceExistingArchive: true

    - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
      artifact: drop

- stage: Deploy
  displayName: Deploy stage
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: Deploy
    displayName: Deploy
    environment: $(environmentName)
    pool:
      vmImage: $(vmImageName)
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            displayName: 'Azure Web App Deploy: <Your name>'
            inputs:
              azureSubscription: $(azureSubscription)
              appType: webAppLinux
              appName: $(webAppName)
              runtimeStack: 'NODE|10.10'
              package: $(Pipeline.Workspace)/drop/$(Build.BuildId).zip
              startUpCommand: 'npm run start' Press button. Commit directly to the branch. It will add this new config file to your project. For the first time, you will be asked for permission (Image 6). “Save and run” Deploying Your Serverless Application Finally, we can deploy our serverless application to Azure (Image 7). Once the upload is complete, your serverless Node.js application should be live on Azure (Image 8). And there you have it — you've just set up a pipeline to deploy serverless Node.js applications on Azure! Take a moment to celebrate this accomplishment. Conclusion As we wrap up, it's crucial to understand the value of setting up a deployment pipeline for a Serverless Node.js application on Azure. We have demonstrated how, through the use of Azure Functions, Azure DevOps, and other Azure services, you can automate your deployment process, ensuring smoother, more efficient, and error-free deployments. Incorporating a pipeline significantly reduces the risk of deployment-related issues and enhances the overall quality of the software. It promotes an efficient development practice that encourages frequent code changes while providing instant feedback on the success of these changes. CI/CD This tutorial should serve as a robust foundation, providing the necessary tools and understanding to further explore the potential of Azure and its integration capabilities. It's now time for you to take this knowledge and apply it to your projects, customizing and optimizing as per your unique requirements. At the end of the day, the goal is to automate processes, increase productivity, and deliver high-quality, efficient applications, and hopefully, this guide has brought you one step closer to achieving that. Happy coding!

How to Set Up a Pipeline for Deploying Serverless Node.js on Azure

or UI refers to the visual and interactive elements that users interact with when using a mobile app. It includes layouts, designs, and presentations of different app-related interface components like text fields, buttons, menus, images, and so many other graphical elements that a good app needs. User Interface Attractive UI captivates the users with an enhanced experience while interacting with the app so, it will be important to keep in mind to design the best possible user-friendly interface to allow users to have a seamless experience while accessing the app’s functionalities. Despite attempting to build a well-executed UI for an app, some bugs could still persist to affect the overall app’s performance. Sometimes, UI issues can be challenging to identify and resolve just like trying to untangle a bowl of spaghetti with a pair of chopsticks—just when you think you've got it, another noodle jumps out😁! So, proper expertise is essential for the systematic debugging of an app. This article is for exploring different debugging methods for UI-related issues. 📥Key Aspects Associated with a Good UI Design A good UI design for a well-functioning app needs several key aspects for creating a visually appealing, intuitive, and user-friendly interface. Here, a few of them are demonstrated in the following figure. The primary goal of a well-designed UI is to create an attractive and user-friendly interface that allows users to easily understand and interact with the app's functionalities which involves the thoughtful arrangement of elements, appropriate colour combinations, font sizes and styles, visual cues, and many more. The debugging process can be performed systematically as follows: 📥Understanding Common & Complex UI Issues or the Bugs to Solve ⬇️Common Bugs: Here are the most common UI-related bugs associated with mobile apps. 👉🏿Layout issues: This issue consists of inconsistent or broken layouts, overlapping elements, and misaligned views that can disrupt the user experience. Here is a code example of the issue and its solution. Misaligned Views: Code Example: <TextView
    android:id="@+id/textView1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Text View 1" />

<TextView
    android:id="@+id/textView2"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Text View 2"
    android:layout_marginTop="16dp" /> ✅Debugging: Here, you can adjust the alignment of views by using proper layout attributes like . gravity, layout_gravity, or layout_alignParent For example, to align the second with the first , you can use : TextView TextView layout_alignTop <TextView
    android:id="@+id/textView1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Text View 1" />

<TextView
    android:id="@+id/textView2"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Text View 2"
    android:layout_alignTop="@+id/textView1" /> 👉🏿Unresponsive controls: It includes non-working UI features like buttons, input fields, or interactive elements that fail to respond to user interactions. ✅Debugging: To debug the unresponsive controls issues, try the following strategies: Verify interactions to ensure that user inputs and actions are properly handled and everything is in the expected behaviour. You can perform repeated regression testing to ensure that new changes or updates do not introduce issues into previously functioning interactions. Keep collecting user feedback and reports that provide valuable insights into the effectiveness and usability of the app's interactions. Examine UI blocking operations to confirm that interactions do not cause the app's user interface to freeze or become unresponsive. Check the event handlers to verify that the app correctly captures and processes user interactions (such as button clicks or gestures). Verify interactions to ensure that the app's intended functionality and user experience are consistently delivered to users. You can use several logging and debugging tools like for debugging the unresponsive control. P.S.: Selenium, Appium, JUnit, TestNG, and Chrome DevTools 👉🏿Inconsistent rendering: Rendering refers to the process involved in the generation of a 2D or 3D image from an app program. UI elements that display differently across different devices or screen sizes can lead to a lack of visual consistency and that will often be problematic. As shown in the figure, the app is not performing properly on specific devices. ✅Debugging: Try the following strategies: Reproduce the issue to understand and investigate the problem thoroughly. You can test the app on different devices and OS versions to ensure compatibility and identify any device-specific issues. Checking layout files ensures proper arrangement and responsiveness across various screen sizes and orientations so it is important to prefer and also manage density independence to ensure. Handling multiple screen sizes involves adapting the UI layout and elements to provide a consistent experience on different devices. Check resource files to guarantee that all necessary assets are present and correctly referenced in the app and review custom views or custom drawable to ensure their correct implementation and proper rendering in an app. Consider GPU rendering and hardware acceleration to optimize the app's graphics performance for smoother rendering. You can use a layout inspector or debugging tools to identify layout issues, view hierarchy, and UI rendering problems during debugging. Test the app with different themes and styles to ensure consistent and visually excellent user experiences across various design choices. User feedback and reports provide valuable insights into issues by allowing for prompt resolution and overall improvement. Regression testing ensures that new changes or fixes do not introduce new issues or disrupt previously working features or functionalities. You can use tools such as which are commonly used in the Android development ecosystem to assist with the mentioned tasks. P.S.: Firebase Test Lab, AWS Device Farm, Android Studio's Layout Editor, Device File Explorer, Android Profiler,  and bug tracking systems 👉🏿Performance issues: App performances get affected due to various factors such as . slow animations, sluggish scrolling, and delays in response time ✅Debugging: Try the following strategies: You could define the performance metrics to allow for the measurement and evaluation of the app's efficiency and responsiveness and also identify the performance hotspots to detect the affected areas of the code that require optimization for improved performance of the app. Monitor memory usage to ensure efficient memory management and identify any memory-related issues or leaks if they persist. Optimize UI rendering to enhance the app's responsiveness and also evaluate network operations to assist in identifying and optimizing potential bottlenecks by reducing latency and improving overall app performance for a better user experience. Next, analyze database queries to ensure efficient data retrieval and manipulation by optimizing app performance. To check parallel execution and synchronization-related issues, Check threading and concurrency. Optimize resource usage (such as CPU and battery consumption) to improve the app's performance and Keep analyzing third-party libraries ensures they are optimized and compatible by minimizing their impact on app performance. Gather user feedback regularly and utilize analytics which provides valuable insights to identify performance issues and prioritize improvements. You can use tools like for performance analysis, monitoring, and testing purposes. P.S.: Android Profiler (Android Studio), Firebase Performance Monitoring, Android Profiler, Xcode Instruments, LeakCanary, Android SQLite Profiler, iOS Core Data Profiler, Android Studio Debugger, Xcode Debugger, and Google Analytics 👉🏿Accessibility problems: Adoption of the app is determined based on how easier it is for any sort of user so, UI elements that are not accessible to users with disabilities can limit the app's usability. ✅Debugging: To address the app accessibility problem, try the following: To ensure inclusivity, it is important to understand accessibility guidelines and standards so, manual testing with assistive technologies can help to identify potential accessibility barriers. Check keyboard navigation to ensure that users can interact with the app using only the keyboard. Accessibility testing tools can automate the detection of common accessibility issues. Provide alternative text for images to enable users with visual impairments to understand their content and verify colour contrast to ensure readability and accessibility for users with low vision. Use semantic markup to enhance the accessibility and understanding of the UI elements of an app. Test voice guidance and feedback to guarantee an inclusive experience for users relying on screen readers. Consider focus management to ensure smooth and intuitive navigation for the keyboard and assistive technology. Seek user feedback and conduct usability testing with individuals using assistive technologies which help to identify accessibility improvements and also keep updating the app. To ensure inclusivity and accessibility, you can use different tools like for preferring the above strategies. P.S.: Axe or Lighthouse, Contrast Checker, Accessibility Inspector, and Accessibility Scanner ⬇️Complex Bugs: Complex issues can arise in the mobile app and sometimes, they remain unnoticed for a long time. Here are some illustrative code examples as the solution for such cases. 👉🏿Slow or Stuttering Scrolling: Probably you have also faced slow scrolling while using some mobile apps through a long list of complex UI. This is due to the bugs associated with the app UI system. ✅Debugging: You might love to use view recycling and asynchronous loading of data techniques to optimize the list or rendering. Here is a code sample. UI RecyclerView recyclerView = findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this));

List<String> dataList = getData(); // Retrieve data for the list

MyAdapter adapter = new MyAdapter(dataList);
recyclerView.setAdapter(adapter); 👉🏿Unresponsive or Laggy UI Interactions This can be the most annoying issue as several UI elements or actions (such as button clicks) take a long time to respond or go unresponsive. ✅Debugging: One of the effective solutions is to move time-consuming tasks or heavy computations to background threads to keep the UI thread responsive for an enhanced user experience. Here is a code sample: Button myButton = findViewById(R.id.myButton);
myButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // Perform time-consuming task on a background thread
        new Thread(new Runnable() {
            @Override
            public void run() {
                // Perform the task
                // ...

                // Update UI on the main thread if needed
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // Update UI elements
                        // ...
                    }
                });
            }
        }).start();
    }
}); 📥How to avoid some common UI design mistakes? If you are focused on designing the best and most attractive app, care to start from the small details or elements. To give the best impressions to users, it is really crucial to avoid some common UI design mistakes which are as follows: 👉🏿Unclear Form: Some confusing forms result in users leaving the app from the very first stage. The form is the first thing that the user starts a journey to the app after creating an account. As shown in the following diagram, just showing an message for an incorrect password could make the user confused. “Error” ✅Solutions: Just using the “ ” indicator may not give an exact clue to the users, try offering detailed clues to take action like “ ”. Red Colour Password Reset 👉🏿Poor touch target Poor touch targets could make users frustrated while accessing the app functionalities. Have a look at the following figure. An option (say play button) provided on the left side is too small to click. ✅Solutions: Make finger-friendly touch targets by enabling the size best suited for any sort of user. 👉🏿Bad icons selection and placement: Unmanaged and wrong icon selection is another UI design mistake. Irrelevant and different-sized icons cannot give a better user experience. ✅Solutions: Use high-quality vectors for your app icons that look sharp with proper contrast. Try to choose a meaningful icon. For example, in the above figure, an icon for music (on the left side) is wrong and icon sizes are not looking to be matched. 👉🏿Too many features Sometimes, including too many features in an app could be problematic as some specific devices may not handle them due to the limitations in the hardware and software resources. It causes several issues like complexities and slow loading UI to affect the overall performance of the app. ✅Solutions: For the best practice, you might try offering the limited features correctly to the users. If your business app should consist of so many features then you can try to include them in the regular updates without breaking the customer relations and trust. 👉🏿Poor IA Here, IA stands for Information Architecture. Generally, most UI designers do not care to include the proper information in the app features. Users may not love to spend much time understanding the app features and functionalities of the information infrastructure that are not properly implemented in the app. ✅Solutions: Perform the research to understand the user’s interests and prioritize the information management systems in your app features and functionalities. For example, you can adjust a note to tell the function about some target elements. Challenges When Debugging UI issues Debugging app UI issues can sometimes be challenging due to various factors like the complexity of modern UI frameworks, variations in devices and browsers, and the inherent difficulty of reproducing and isolating the issues. Here are some common challenges you might encounter when debugging UI issues as shown in the diagram. Conclusion: A well-executed UI design is essential for capturing and retaining users' attention as it influences their perception of the app's quality, usability, and overall satisfaction. By focusing on creating a well-decorated, visually pleasing, and accessible UI, app developers can enhance user engagement, and encourage mass app usage or adoption. in mobile apps requires proper expertise and a thorough understanding of common to complex problems. By utilizing logging, testing, analyzing performance, and employing appropriate debugging tools, developers can effectively identify, diagnose, and resolve UI-related issues. Remember, proactive debugging and continuous improvement of the UI are crucial to maintain user satisfaction and driving the success of mobile apps. Debugging UI issues

Debugging User Interface (UI) Issues in Mobile Apps: A Comprehensive Guide

Churches Are Breaking the Law and the IRS Isn't Doing Anything About It

Polygon is a new web browser for smartphones, it is set to revolutionize how we use Ethereum. The network has already received much attention from the community. In fact, big companies like Nike, Reddit, and Starbucks adopted the blockchain-powered solution. So, what exactly makes it so special? Well, let me give you a fuller runover. The Rise Of Polygon Network Polygon is a new Ethereum-based network created by some of the brains behind the second-biggest cryptocurrency in history. Its main goal is to make Ethereum faster and cheaper while making it easier for users. The blockchain was previously named as the MATIC network, but in February 2021, it rebranded to the Polygon network. Currently, MATIC is an token on the Ethereum blockchain serving as the native token for Polygon. ERC20 The investments and big collaborations in Polygon also fostered its growth. For instance, its partnership with the consulting wing of Infosys Limited, . The partnership would enable Infosys to provide emerging technology services to its customers and M-Setu would become an open-source bridge for brands to cross-operate on the Ethereum blockchain. M-Setu On May 25, 2021, the billionaire crypto investor, Mark Cuban shared that he has invested in Polygon and this is still visible in his on the Mark Cuban companies website. He said that Polygon has a high transaction per second TPS and that is important to reduce the transaction cost for users. On May 28, Polygon made a huge announcement of which would allow the users of Big Query to adopt Polygon thereby, increasing its flexibility and brand positioning. company’s portfolio integrating its asset into Google Cloud’s Big Query What is the hype all about? Recently, there has been so much hype building around the Polygon blockchain, it is considered a potential game changer in the world of dApps. Well, that is because it is the first Ethereum 2.0 network with more flexibility and accessibility. The network will be faster than Ethereum and cheaper to run, in fact, its cost per transaction could be as low as $1. Also, Polygon uses a new technology called C++ scala that makes it possible for developers to write their code once, then compile it into multiple languages like Java or JavaScript and run it on any computer system without needing any special hardware if you have an internet connection (and sometimes even when you don’t). The Polygon hype doubled when to help creators mint and sell Polygon NFTs (Non-Fungible Tokens) on . Meta partnered with polygon Instagram In addition, for a technology that once struggled to raise funds, Polygon started to attract the interest of venture capitalists with its innovative technology. In February 2022, it raised in India. Through a private sale of its native token, MATIC, to expand its scaling solutions and improve operations. $450m from Sequoia Capital Polygon vs Ethereum: What is the difference? The Polygon Network is a new blockchain that will be faster and cheaper than Ethereum, but it also has some advantages over Ethereum itself. Polygon is an open-source project, meaning anyone can contribute code or otherwise help make it better by providing feedback on how they can improve their own experience with the network itself. They are not just going through the motions when creating this new product, they really want people who are using it now - whether it is as part of their everyday lives or just because they like what this platform stands for - to feel involved in its development process as well. The difference between Polygon and other cryptocurrencies like Bitcoin or Litecoin is that instead of using Proof-Of-Work (POW) to confirm transactions, it uses delegated proof-of-stake (DPOS). DPOS allows anyone with enough stake in the network (which means holding at least 10% of all tokens) to vote on who will be chosen as block producers or validators. The more coins you hold within Polygon networks, the greater chance you have of being selected as the next block candidate during POS voting rounds. If you are selected as the winner then the transaction fees will be paid out into your account as rewards. This allows the producers to have greater control over how much power they have over the network. Also, this is more incentive than other cryptocurrencies offer since the block producers get paid based on how many blocks they produce each day instead of being rewarded for solving difficult puzzles. Although, unlike the Ethereum network which is more private and secure, Polygon is more decentralized. However, this gives it better scalability than Ethereum because Polygon counterbalances lesser security with its flexibility. This does not mean that the polygon network is entirely unsafe, just that it is not as secure as its layer1 blockchain (Ethereum). Conclusion Many people do not understand Ethereum and what it does, but Polygon should be a good way for them to get into blockchain. The company is making progress and has already launched new products that will make blockchain transactions faster than ever before without any transaction fees or stress. This means that people who want to get involved with cryptocurrency will have no excuse but to use Polygon as their go-to site when they need their things done quickly. Also published here.

What’s All the Polygon Hype About?

Ransomware is one of the most dangerous threats to many industries and businesses nowadays. Ransomware attacks cause material losses amounting to millions of dollars per year worldwide, and this amount is growing year after year. There are different ransomware families, and Cerber ransomware is one of the most devastating. This blog post covers Cerber ransomware, infection methods, the working principle, how to remove Cerber ransomware, and how to protect against Cerber. The typical behavior of Cerber is explained to help prevent and deal with this dangerous type of ransomware. General Information About Cerber Ransomware What is Cerber ransomware? Cerber is a type of ransomware that infects computers and encrypts files. Cybercriminals then demand victims pay ransom in bitcoins to receive a key that releases the files. However, there is no guarantee that a victim can get the data back after paying a ransom. The first version of Cerber ransomware was created in 2016. In 2018, it seemed that Cerber attacks had stopped. But in 2020, Cerber came back, and new attacks were launched with updated versions of this ransomware. Cerber ransomware uses the ransomware as a service (RaaS) model for distribution. Cerber is highly customizable ransomware. Ransomware attackers can become affiliates, use ransomware provided by Cerber developers, and split the ransom (pay about 40% of the received ransom money) to the Cerber developers. This approach allows cybercriminals to launch more attacks with less work. The statistics on ransomware infections are staggering. More than 52 million attacks were launched in the first half of 2021. Both enterprises and individual users are being targeted. Organizations in diverse industries were targets of ransomware attacks with Cerber. No one is safe from Cerber ransomware. Examples of how antivirus software detects Cerber: Win32/Filecoder.Cerber.B Ransom.Cerber Ransom:Win32/Cerber Win-Trojan/Cerber.Gen RANSOM_CERBER Trojan.GenericKDZ.39212 NSIS/Ransom-Cerber.a How Cerber Ransomware Works Sophisticated techniques are used to infect computers and encrypt files. Let’s explain how victims are infected to understand infection vectors and how to protect against Cerber ransomware. Spam, malvertising (malware-infected ads on websites), exploit kits, and exploitation of vulnerable websites are methods to infect computers. The main attack vector is spam and phishing emails sent to victims. An email message contains text that manipulates a victim and tricks them into opening an attached file. Attackers use social engineering to compose an email that seems legitimate, for example, an email from a bank, delivery service, etc. Usually, a Word document with malicious macros is attached to the email message. Microsoft Office Exploits can be used. When a user opens the infected DOCX file, the macro in the document writes a piece of Visual Basic Script (VBScript) into memory and executes this script. The VBScript initiates running PowerShell in hidden mode and can bypass PowerShell execution policies. The command is executed in PowerShell for connecting to a malicious site and downloading the Cerber ransomware payload. If the connection is successful, then an executable Cerber file is downloaded to the computer and executed in PowerShell. There are Cerber versions that use JavaScript instead of VBScript. The malware file hash can change every few seconds to a newer timestamp with appending data bytes to avoid being detected by using hash-based methods. A double-zipped file, such as a self-extracting archive (SFX), with a malicious Windows Script File (WSF) is another variation of the attached file. A phishing email can contain an unsubscribe link that redirects to the same malicious Cerber file. The archive contains three files: A66K.DLL N3W7MN.VBS X There are versions of Cerber ransomware with installers that contain a .ch file and .caz shellcode file with the code to decrypt the executable .ch file. In this case, Cerber uses Nullsoft Scriptable Install System to hide. Note that file names, file locations, configuration formats, and other parameters can change with the release of new versions of Cerber ransomware. Wscript.exe is used to run the VBScript that executes a DLL export through rundll32.exe, which decrypts data from the X component and executes malicious code. The X component is completely encrypted. The first encrypted part is loaded from X and is used to check techniques for reversing analysis and research of Cerber ransomware (anti-emulation and anti-debugging techniques). The second part of the X component is extracted and injected into Regasm.exe or WerFault.exe, where it is hidden. This second component checks for .NET Framework. If .NET Framework is found, Cerber checks the version of the framework and injects a malicious code. If .NET Framework is not found, Cerber injects code into WerFault.exe. Thus Cerber ransomware can infect both 32-bit and 64-bit Windows operating systems. Anti-emulation techniques Cerber checks files and directories that can indicate that it’s running inside virtual machines (VMs) or sandbox environments to make researching more difficult for security experts. Cerber checks for anti-virus and anti-malware software by checking directories that can indicate that this software is installed. Cerber checks whether a traffic analyzer (sniffer) like WireShark is installed. Cerber checks whether it’s running inside a virtual machine under a VMware, Hyper-V, VirtualBox, QEMU, or Parallel virtualization platform. In order to check whether Cerber ransomware is running on a VM, Cerber checks the registry key: HKLM\SYSTEM\CurrentControlSet\Enum\PCI Each subkey in this registry key represents a Peripheral Component Interconnect (PCI) device installed for the machine by using this format: VEN_XXXX&DEV_XXXX&SUBSYS_XXXXXXXXX&REV_XX VEN represents a Vendor ID, DEV represents a Device ID in the hexadecimal format (HEX). When hardware virtualization is used, hardware devices are emulated. Virtual devices use the appropriate Vendor IDs and Device IDs, depending on the hardware virtualization platform on which the VM is running. If Cerber ransomware detects that Cerber is running in a VM, the ransomware terminates itself. However, you still need to regularly perform VM backup. Cerber also tries to find the VMware substring that indicates that it’s running inside the VMware VM and strings pointing to the VMs of other vendors in the registry key: HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\SystemBiosVersion Configuration Cerber ransomware is highly configurable. Lists and tags are defined as configuration parameters. A list of blacklisted countries in the JavaScript Object Notation (JSON) format is created to avoid infecting computers that are connected to the internet by using the IP addresses of these countries. Cerber identifies the country by checking the public IP address of the potential victim. The system keyboard layout is also checked to avoid infecting computers from the blacklisted countries. The countries excluded from ransomware attacks in the Cerber configuration are Russia and some neighboring countries. Security researchers presume that Cerber creators were located in Russia and wanted to target developed countries to get more money from victims. An attack is avoided if Cerber detects that one of these keyboard layouts is installed as the system keyboard layout on a computer: 1049—Russian, 2115—Uzbek (Cyrillic), 2092—Azeri (Cyrillic), 1068—Azeri, (Latin), 2073—Russian (Moldova), 2072—Romanian (Moldova), 1091—Uzbek (Latin), 1090—Turkmen, 1088—Kyrgyz (Cyrillic), 1087—Kazakh, 1079—Georgian, 1067—Armenian, 1064—Tajik, 1059—Belarusian, 1058—Ukrainian. Once executed, Cerber ransomware checks the directory from which the ransomware has been launched. If Cerber is not launched from %APPDATA%\&#60GUID&#62, then a copy of the Cerber file is created in the %APPDATA% directory of a user on a Windows machine. The file name is selected randomly by using one of the file names in the %WINDIR%\system32 directory for better masquerading. Bypassing Windows protection Bypassing Windows protection and changing Windows configuration is another part of Cerber’s aggressive behavior. User Access Control (UAC) checks are bypassed. Cerber ransomware deletes Volume Shadow Copies to disable Windows restore options and disables safe boot options to avoid repairing Windows after infection. Vssadmin.exe "delete shadows /all /quiet" WMIC.exe "shadowcopy delete" Bcdedit.exe "/set {default} recoveryenabled no" Bcdedit.exe "/set {default} bootstatuspolicy ignoreallfailures Cerber performs multiple manipulations to make the configuration persistent, run encryption after reboot, and display notifications after finishing file encryption: Adding a task in Windows Scheduler. The tasks are stored in %WinDir%\Tasks or %WinDir%\System32\Tasks. Changing the CommandProcessor autorun key value for pointing to the Cerber payload. After that, ransomware is executed each time CMD.exe is launched. Editing a registry key to launch ransomware instead of a screensaver. Run and runonce keys are also used. A shortcut file (LNK) that references the ransomware is added to the Startup directory. As a result, Cerber ransomware executes automatically after a user logs into Windows. Connecting to external servers on UDP port 6893, sending encrypted information, and saving some received encrypted information to the disk is performed when preparing to encrypt files. At this time, Cerber ransomware can encrypt 294 file extensions. This number has significantly increased compared to the first version of Cerber. File encryption AES-256 (RSA-2048) and RC4 encryption algorithms are used to encrypt files that are accessed from the infected computer. A 256-bit key is generated on the victim’s computer and then protected with a 2048-bit key. AES encryption is asymmetric – encryption and decryption keys are different. The encryption key is a public key and the decryption key is a private key. The decryption key is needed to decrypt the encrypted files, but the decryption key cannot be generated if the encryption key is available. Cerber initiates killing processes that have opened files because the opened file is locked by an application using this file and ransomware cannot encrypt this file. Cerber attempts to close database software to encrypt database files. This ransomware can also close applications like Word, Excel, and others to encrypt documents that are opened. The list of the processes that can be killed is defined in the Cerber configuration with the close_process list tag. Cerber encrypts accessible files (that have supported file extensions) including network disks and file shares. Encrypted files cannot be opened as usual if you rename file extensions. Encrypted files have extensions like: .cerber, .cerber2, .cerber3, .af47, .a48f, .ba99, .beef, or random characters. Random names make it more difficult to scan and find the files that were encrypted. There is a known algorithm for how these random file extensions are generated. Cerber ransomware checks this registry entry before generating the extension that will be used for encrypted files: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\MachineGuid The format of MachineGuid is the following: XXXXXXXX-YYYY-ZZZZ-AAAA-BBBBBBBBBBBB Eight characters in the first part (XXXXXXXX in this example) are used to generate a directory name for Cerber in the %TEMP% folder. Four characters in part 2 and part3 (YYYY, ZZZZ) are used to name Cerber component files. Four characters in part 4 (AAAA) are used to name the extensions of the encrypted files. System files of an operating system (OS) are not encrypted to allow OS to boot and display the ransom note. Once the file encryption has finished, the desktop wallpaper is changed and additional ransom notes are added in .txt, .vbs, .hta, and .html files on the desktop and in other folders. Cerber ransomware kills itself (kills the task in CMD or PowerShell), and the original payload executable files are hidden or deleted after finishing encryption. Examples of the note files: README.hta _READ_THIS_FILE.hta # HELP DECRYPT#.html # DECRYPT MY FILES #.txt # DECRYPT MY FILES #.html HELP_HELP_HELP[random characters].hta _R_E_A_D___T_H_I_S___[random]_.txt _R_E_A_D___T_H_I_S___[random]_.hta These notes contain a link to download the TOR browser, a link to the website on the dark web, where payment can be made, and instructions. The text notification can be accompanied by an audio message when opening the VBS file. Notes are provided in 12 languages including English, German, Spanish, French, Italian, Polish, Turkish, Dutch, Japanese, and Chinese. Attackers demand the victim pay a ransom within 7 days. After 7 days have passed, the price is doubled. New versions of Cerber can add an infected computer to a botnet used for distributed denial of service (DDoS) attacks and other illegal activities. This tactic allows attackers to get an advantage even if the victim doesn’t pay the ransom. What to Do if a Computer is Infected? If you see that a computer is infected with Cerber ransomware, take these actions: Don’t pay a ransom because paying the ransom finances cybercriminals and inspires them to launch more attacks. Disconnect the infected computer from the network. Power off the computer to stop encryption (if the encryption is in progress). These actions can avoid infecting other computers connected to the network. Report the ransomware to the authorities. Remove Cerber ransomware. Try to recover corrupted files. How to Remove Cerber Ransomware In order to remove Cerber ransomware, follow these steps: Boot from a Live DVD, because the installed OS infected with ransomware cannot work properly. Scan files on the infected computer with antivirus software. Delete the infected files. How to Recover Files Encrypted with Cerber Ransomware Unfortunately, removing Cerber ransomware doesn’t recover encrypted files. Try to perform these actions for file recovery: Search for a decryption tool. Some decryption tools were published for the first versions of Cerber ransomware. Later, cybercriminals modified Cerber to avoid decryption. If there is no decryption tool and decryption is not possible, leave the disk drives with corrupted files in the archive. A decryption tool probably will be released at some point. Try to use software to restore deleted files. If you have a data backup, restore the needed files from the backup. It is recommended that you reinstall the OS that was infected with Cerber ransomware because the infected OS will not function properly. A better method is to recover a partition with the OS from a backup image. How to Protect Against Cerber Ransomware The strategy for protecting against Cerber ransomware is similar to the general strategy of ransomware protection. Educate users not to open suspicious links, emails, and file attachments. Use anti-malware protection on an email server. Organizations using Office 365 can use Exchange Online Protection and Advanced Threat Protection. Install anti-virus software on computers and regularly update anti-virus databases. Patch software vulnerabilities when software updates are released. Respect the security policy and provide writing access to shared files only for those who need it. Back up your data regularly and respect the . Restrict access to backups. If you store backups on media that is offline (for example, on a disconnected hard disk drive or a tape cartridge), ransomware cannot access and corrupt the data of backups. 3-2-1 backup rule Conclusion Cerber ransomware is extremely dangerous because this ransomware can corrupt most files on a computer. Knowing the behavior and working principles of Cerber can help you detect this ransomware. This blog post has covered Cerber ransomware and explained how Cerber works, how to remove Cerber ransomware, how to protect against Cerber attacks, and how to recover data if files were corrupted. The most effective methods to protect your files against ransomware are preventive measures. Use antivirus protection, patch vulnerabilities, educate users, configure user access to resources properly, and perform data backup regularly.

Cerber Ransomware Explained: How to Protect, Detect, and Recover

Most people have electronic junk drawers where their outdated smartphones and computers pile up. The digital era is creating new material recycling challenges, and limited access to electronic waste (e-waste) processing systems and recycling leads to hoarding old devices. Individuals can take recycling measures into their own hands by selling their old electronics. However, it’s vital to clear hard drives and clean externals. People can receive competitive offers for their used computers by following essential sale preparation steps. Why Are Consumers Selling Their Computers? More consumers are selling their old computers than ever before. They stopped throwing away their old electronics to minimize e-waste, protecting the global ecosystem in the process. The U.S. worth of e-waste every second. This creates toxic pollution, which travels to the oceans through stormwater runoff. Individuals can protect marine ecosystems by reselling their laptops instead of sending them to landfills. generates nearly 800 laptops Consumers are also selling their used computers to upgrade their home offices. More employees have engaged in remote work since the COVID-19 lockdown and are replacing their laptops with desktops. Other people sell their old computers to gain extra income. They can spend a portion of their profits on purchasing an upgraded device. Ultimately, selling used computers is an environmentally and economically responsible decision. Why Is Computer Sale Preparation so Important? People can prepare their used computers for resale to increase their profits. Proper preparation techniques may help owners protect their personal information and reduce e-waste. Individuals who fail to clear their computers’ hard drives before reselling increase their susceptibility to hackers. Criminals are techniques to acquire credit card information, addresses, and Social Security numbers. It’s vital to clear personal information from computers to stay safe. advancing hacking and theft Computer sale preparation may also reduce the time a device spends on the market. Individuals can increase their chances of selling an item by optimizing its efficiency and operations. Resetting a used computer and deleting unnecessary features can improve its processing speeds. Improving a computer’s functions and aesthetic can also lead to a quick sale. There are six computer sale preparation techniques helping individuals reduce e-waste and make the most money from their old electronics. 1. Estimate the Computer’s Price The first step to take before selling a used computer is to estimate its market price. Individuals can acquire estimates using online price range tools, which are easy to use and provide a realistic range of potential offers. People may also calculate their computers’ price ranges by accessing manufacturing information. This can help owners determine how and when companies produced a device. Consumers can then compare their prices to similar products on the market. Computer owners can use their findings to identify which offers are competitive. Estimating prices is an essential step for individuals selling their electronics independently. They can avoid getting burned on reselling websites by determining their computers' potential cost. Typically, MacBooks will sell at a higher price than a Windows computer. macOS of the operating system market, compared to Windows’ 76%, making the demand for a Mac higher. However, this is just a general rule and does not take into consideration a computer’s age, quality and countless other factors. holds only 16% 2. Back up Personal Files It’s vital to back up personal files. Most modern laptops and desktops allow users to upload their files to the cloud. Individuals can ensure everything is there before wiping data from their hard drives. Older computers may require an external hard drive to secure important data. Individuals can purchase them at tech stores and directly onto their hard drives. copy essential files People can also set up automatic file backup systems to increase a computer’s security. Windows and Mac products have auto-backup features, which frequently create copies of folders and files. Individuals should ensure their backup settings are active to secure their data before wiping the internal hard drive clear. 3. Sign Out of All Accounts Computer owners should also sign out of all their accounts. People can use many computer additives, and they often forget to sign out of their Microsoft accounts before selling their computers. Consumers can access previous owners’ personal information through Microsoft accounts. They may also gain access to Microsoft amenities, which previous owners may pay for. Individuals can protect their sensitive information by signing out of all their banking, social media, communication, and other sites. 4. Erase the Hard Drive People can clear their computers’ internal hard drives by connecting their devices to a Darik’s Boot and Nuke (DBAN) system. They may do so using USB cords. Individuals can restart their devices once they connect to DBANs. Computers will display a boot prompt after the reboot, and to stimulate a complete hard drive wipe. Clearing a hard drive can eliminate the next user’s access to important information. users should type “autonuke” 5. Clean the Computer’s External Components Another thing to do before selling a computer is clean its external components. Individuals should place their electronics back on the market in the condition they received them. They can improve their computers’ aesthetic by cleaning the keyboard, screen, speakers, and vents using low-impact materials. People should power down their electronics . They can use lint-free cloths to remove dust from a computer’s surface and clean keyboards by flipping them upside down and shaking out debris. before cleaning to eliminate safety hazards They can also use certified computer vacuums to suck dust out of speakers and vents. Keeping a computer’s fan clean can improve its general efficiency. 6. Find a Resale Service The final step before reselling a computer is finding a reliable resale service. There are many online companies helping individuals connect with potential buyers. Computer owners should determine how much a website takes from a sale to optimize their profitability. They may also use independent sales platforms to receive 100% of the profits. Facebook Marketplace, Craigslist, and eBay connect resellers with buyers. Individuals can also resell or trade their old computers through the original manufacturer. What to Expect When Selling a Computer People can make the most of their used computer sales by effectively preparing. Resellers should also ensure safety precautions are taken while independently exchanging used electronics by meeting in public locations. They may also consider shipping their items instead of meeting buyers in person. Manufacturers may offer owners less for their used computers than independent consumers. Individuals can determine the price gap before reaching out to manufacturers to remain prepared. Sellers should explore multiple offers before finding the best buyer and making the most profit they can.

What to Do Before Selling a Computer

There is no instruction to the decision-making process. However, important decisions are usually made by analyzing tons of data to find the optimal way to solve a problem. That’s where we truly rely on logic and deduction. That’s why surgeons dig into anamnesis, or businesses gather key persons to see a bigger picture before making a turn. Relying on AI decision-making can significantly reduce the time spent on research and data gathering. But, as the final decision is up to the human, we still need to understand how our support system came up with these insights. So in this article, we’ll discuss AI explainability and why it’s important for such areas as healthcare, jurisprudence, or finance to justify any piece of information. What is explainability in AI? AI decision-support systems are used in a range of industries that base their decisions on the information. This is what’s called a data-driven approach – when we try to analyze available records to extract insights, and support decision-makers. The key value here is data processing, something a regular person can’t do fast. On the flipside, neural networks can grasp enormous amounts of data to find correlations and patterns, or simply search for the required item within an array of information. This can be applied to domain data like stock market reports, insurance claims, medical analysis, or radiology imagery. The problem is that, while AI algorithms can derive logical statements from data, it remains unclear what these determinations were based on. For instance, some computer vision systems for lung cancer detection show up to in their predictions. But can a pulmonologist rely just on model prediction without knowing if it is not mistaken tumor for fluid? 94% accuracy This concept can be represented as a black box, as the decision process inside the algorithm is hidden and often can’t be understood even by its designer. refers to techniques by which a model can interpret its findings in a way humans can understand. In other words, it’s a part of AI functionality that is responsible for explaining how the AI came up with a specific output. To interpret the logic of AI decision processes, we need to compare three factors: AI explainability Data input Patterns found by the model Model prediction These components basically are the essence of AI explainability implemented into decision-making systems. The explanation in this case, can be defined as how exactly the system provides insights to the user. Depending on the implementation method, this can be presented as details on how the model derived its opinion, a decision tree path or data visualization. AI decision-support system types Decision-support systems can be categorized by purposes and audiences. But we can split them into two large groups: consumer and production-oriented. The first group of systems unites AI decision making systems that are generally used for everyday tasks. Tools like recommendation engines don’t require explainability as it is. We don’t question the logic behind music recommendations made by neural networks. Unless it suggests complete garbage, it’s unnecessary to know how the system picked that song and brought it to you. You’ll probably just listen to it. consumer-oriented , in contrast, usually deal with critical decisions that require justification. This is like how a person in charge of a final decision is responsible for any possible financial loss or harm. In this case, the AI model acts as an assistant for professional activity, providing explicit information for a decision-maker. Production-oriented systems So now, let’s look at the examples of explainability in production-oriented AI systems and how it can support decision-makers in , finance, social monitoring, and other industries. healthcare Explainable AI for medical image processing and cancer screening Computer vision techniques are actively used in the processing of medical images, such as Computed Tomography (CT), Magnetic Resonance Imaging (MRI), and Whole-Slide images (WSI). Typically, these are 2D images used for diagnostics, and surgical planning, or research tasks. However, CT and WSI can often depict the 3D structure of the human organism reaching enormous size. For example, WSI of human tissues 21,500 × 21,500 pixel size and even more. Efficient, fast and accurate processing of such images serves as the basis for early detection of various , such as: can reach cancer types Renal Cell Carcinoma Non-small cell lung cancer Breast cancer lymph node metastasis The doctor’s task in this case, is to strip the information down to visually analyze the image to find suspicious patterns in the cellular structure. Based on the analysis, the doctor will provide diagnosis, or make a decision for surgical intervention. However, since WSI is a really large image, it takes heaps of time, attention and qualification to analyze. Traditional computer vision methods will also require too much computational resources for end-to-end processing. So how can explainable AI help here? In terms of WSI analysis, explainable AI will act as a support system that scans image sectors and highlights regions of interest with suspicious cellular structures. The machine won’t make any decision, but will speed up the process and make the work of a doctor easier. This is possible because WSI is more accurate and quicker in terms of image scanning, giving less chance to omit specific regions. Here is an of renal clear cell carcinoma on the low resolution WSI. example As you can see on the image on the right, the AI support system highlights the regions of high risk where cancer cells are more likely to be. This eliminates the need to physically analyze the whole image of a kidney, providing hints for medical expertise and attention. Similar heatmaps are used for even closer and more high resolution analysis of kidney tissue. The advantage of such systems is not only in operational speed and greater accuracy of analysis. The image can also be manipulated in different ways to provide a fuller picture for diagnostics and to make more accurate surgical decisions if needed. You can check the of kidney tissue WSI analysis to see how the interface looks and how exactly it works. live demo Explainable AI for text processing Text processing is a standalone task, as well as a part of bigger workflows in different industries such jurisprudence, healthcare, finance, media, and marketing. There are plenty of techniques for deep learning that are capable of analyzing text from different angles. Here we can list , natural language understanding (NLU), and generation (NLG). These algorithms can classify text by its tone and emotional shades. It can also detect spam, produce a short summary, or generate a large contextual text based on a small initial piece. natural language processing (NLP) Besides use in document processing, machine translation, and communication technologies, there are other applications based on explainable AI. SELF-HARM OR SUICIDE PREDICTION One of the applications of text classification was found in . Facebook employees have developed an algorithm that allows you to determine users’ suicidal moods based on an analysis of the text of their posts, as well as responses to these posts of relatives and friends. Meta If suddenly the system gives a signal that there is a high probability that a person can harm himself, then this information is submitted to the community operations team for manual processing and verification. Explainable AI supports teams with constant scanning of media fields to find risky commentaries. After that, the human agent can use data explanations presented by the model that will point to how the machine understood if that unique person is showing the risk for suicide. FINANCIAL NEWS MINING Another interesting case is, for example, the use of financial news texts in conjunction with fundamental analysis to forecast stock values. A prime example of this would be “trading on Elon Musk’s tweets,” whose tweets had a dramatic effect on the value of several cryptocurrencies (Dogecoin and Bitcoin), as well as the value of his own company. The point is that if someone can impact stock prices so much through social media, it is worth knowing about these posts in advance. AI algorithms allow you to process a huge number of news headlines and texts in the shortest possible time by: analyzing the tonality of the text identifying the runoff or company referred to in the article identifying the name and position of the specialist quoted by the publication All this allows you to quickly make decisions on a purchase or sale, based on the summary of social media information. In other words, such AI applications can support individuals and businesses in their decision by supplying information about recent events that could impact stock prices and different fluctuations in the market. The explainability part is responsible for justifying the data by recognizing company, event, persona, or resource entities with named entity recognition technology. This allows the decision-support system user to understand the logic behind the model’s prediction. What do we need to make the work of AI algorithms with text understandable? We need to uncover the patterns AI “saw” in the text. We want to see what words and connections between the words that the algorithm relied on, proving its conclusion about the tonality of the text. How AI explainability works in text processing Consider explainable AI using the example of financial news headlines of articles. Below will be several headings and the reader is invited to assess the tonality of these headings (positive, neutral, negative), as well as try to track and reflect on which words in the title you, as a reader, relied on when you assigned the title to a particular group: Brazil’s Real and Stocks Are World’s Best as Foreigners Pile In Analysis: U.S. Treasury market pain amplifies worry about liquidity Policymaker Warns of Prolonged Inflation due to Political Crisis A 10-Point Plan to Reduce the European Union’s Reliance on Russian Natural Gas Company Continues Diversification with Renewables Market Software Firm Partnership Now let’s compare your expectations with how these headers classify AI and see what words were important for the algorithm to make a decision. In the pictures below, the words on which the AI algorithm relies in making a decision are highlighted. The redder the shade of the highlight, the more important the word was in making the decision. The more the shade was blue, the more the word tilted the algorithm toward making the opposite decision. Brazil’s Real and Stocks Are World’s Best as Foreigners Pile In
Class: Positive 2. Analysis: U.S. Treasury market pain amplifies worry about liquidity
Class: Negative 3. Policymaker Warns of Prolonged Inflation due to Political Crisis
Class: Negative 4. A 10-Point Plan to Reduce the European Union’s Reliance on Russian Natural Gas
Class: Neutral 5. Company Continues Diversification with Renewables Market Software Firm Partnership
Class: Positive How long did it take you to read all these headlines, analyze and make a decision? Now imagine that AI algorithms can do the same, but hundreds of times faster! How to integrate Explainable AI features into your project? One might think that the integration of explainable AI into a project is quite a sophisticated and challenging step. Let us demystify it. In general, from the perspective of explainability, AI systems may be classified into two classes: Those which support explainability out-of-the-box Those which need some third-party libraries to be applied to make them explainable The first class of AI includes instance and semantic segmentation algorithms. AI algorithms based on attention are good examples of self-explainable algorithms we’ve shown above based on examples of WSI kidney tissue cancer risk images. The second class of AI algorithms, in general, doesn’t support out-of-the-box self-explainability. But this doesn’t make them completely unexplainable. As an example of such an algorithm, we’ve shown text classification above. We can use 3rd-party libraries on top of AI algorithms that make them explainable. Usually, it is easy to use LIME or SHAP libraries to make your AI explainable. However, the explainability requirements may differ on the project or user objectives, so we suggest you enlist the support of an AI expert’s team to receive proper consulting and development. AI-explainability enhances trust One of the key factors that prevents mass adoption of AI is the lack of trust. Decision-support tools in data driven organizations already perform routine tasks of reporting and analysis. But at the end of the day, these systems are still not capable of providing a justified opinion on business-critical or even life-critical decisions. Explainable AI is a step further in data-driven decision making, as it breaks the black box concept and makes the AI process more transparent, more verifiable and trusted. Depending on the implementation, a support system can provide more than just a hint, because as we track down the decision process of an AI algorithm, we can uncover new ways to solve our task, or be provided with optional types of decisions. . Featured image credits: Tara Winstead Written by , AI/ML Team Leader at . Evgeniy Krasnokutsky MobiDev The full article was originally published and is based on MobiDev technology research. here

Using Explainable AI in Decision-Making Applications

Last July, I started writing a series focused on how the Salesforce platform can be utilized in a manner without a traditional Salesforce client. Here are links to the other articles in the series: Leveraging Salesforce Using Spring Boot Leveraging Salesforce Using a Client Written In Svelte Leveraging Salesforce Using a Client Written In Vue.js Leveraging Salesforce Using Mobile Applications Written (Once) In React Native Leveraging Salesforce Using a Client Written In Angular A graphical representation of the series is shown below: The illustration above shows how various client frameworks can access the Salesforce data without actually utilizing clients provided by the Salesforce ecosystem. Recently, I started a new series to demonstrate the , which harnesses the power of the Salesforce platform within standalone mobile apps. Salesforce Mobile SDK A graphical representation of this new series is shown below: “ ” was the first article in this Mobile SDK series. In this article, I will focus on using Android Studio to produce the same application. Exploring the Salesforce Mobile SDK Using React Native Benefits of the Salesforce Mobile SDK The Salesforce Mobile SDK provides several benefits for software engineers: Allows custom mobile device applications to utilize Salesforce features and functionality Full access to Salesforce functionality (no need to reinvent the wheel) Applications can be distributed using the application store of the native device Processing push notifications from Salesforce The ability to work with Salesforce data in an offline mode If your application landscape utilizes Salesforce for key aspects of business operability, then consider leveraging the Salesforce Mobile SDK. By doing so, you can integrate data maintained by Salesforce into key component locations, allowing you to make strong business decisions. Benefits of Using Android Studio If your client base requires support for Android devices and you wish to use Android Studio for app development, then you’ll find value in the CLI for getting started quickly with Salesforce functionality. forcedroid Key features for teams employing Android Studio include: Uses Java or Kotlin as the base programming language Provides 100% native support for features and functionality on Android devices Allows experienced Android developers to quickly leverage Salesforce Mobile SDK functionality The long-term roadmap of features/functionality—along with the quality of ongoing support—tends to favor Android Studio over React Native Now that we’re ready to dive in, let’s briefly review our use case. Finny’s Foods: An Example Use Case Having a son (Finny) born with special needs introduced a personal desire to gain an understanding and appreciation of the products we use in our daily life. Years before Finny was born, my wife (Nicole) and I lived a healthy lifestyle. However, as Nicole began deep-diving into the ingredients in the foods that made up our daily diet, we received a much-needed wake-up call. Fast-forward to today, our diet consists of few processed foods, no gluten, low sugar, and very little dairy. As much as possible, our protein originates from grass-fed sources, and we always favor organic options. Don’t get me started on GMO. For this series, our Finny’s Foods application provides a simple list of meals that are both acceptable to us and favored by Finny. For now, we will include two simple attributes for each meal: Name of the meal Rating (1 to 5, where a rating of 5 is an absolute favorite for Finny) Over time, I plan to introduce other attributes (such as summary, ingredients, directions, and even a photo), but let’s walk before we run. Getting Started with Android Studio In addition to installing and on my MacBook Pro, I made sure my Android Studio version was up to date. Next, I visited the following URL to make sure everything was set up and configured as expected: git npm Set Up Your Android Development Environment These steps include installing Android Studio, the Android SDKs, and at least one Android emulator (AVD) and the CLI. forcedroid Next, I executed from a terminal session with the following options: forcedroid forcedroid create

Enter your application type (native_kotlin or native, leave empty for native_kotlin): native
Enter your application name: finnys-foods-android
Enter your package name: com.gitlab.johnjvester.finnysfoods.android
Enter your organization name (Acme, Inc.): JVC
Enter output directory for your app (leave empty for the current directory): Once completed, I started Android Studio and imported the new finnys-foods-android project as documented in the following URL: https://developer.salesforce.com/docs/atlas.en-us.noversion.mobile_sdk.meta/mobile_sdk/android_new_project.htm Creating the Meal Object in Salesforce Before I could begin creating a new application in Android, I needed to establish the Meal object in Salesforce. I already had a Developer org that I could use. (You can create a new one .) So, I simply logged in using my email address and password for that org. Next, I navigated to the and the perspective in Salesforce. here Apps | App Manager Setup I created a new Lightning App called Meal: On the remaining setup screens, I selected all the default settings and granted access to all Salesforce User Profiles. Next, I visited the menu option in the Salesforce Settings. Once I located the newly-created Meal item, I used the drop-down component to the object. Objects & Fields | Object Manager Edit I switched from the submenu to the option. I quickly realized I did not need to create a Name property for my Meal object since Salesforce already took care of that for me. I just needed to add the Rating field. Details Fields & Relationships Using the button, I selected the field type and populated Step Two as noted below: New number I used the default values and saved my new field. Now, I can use both the name and rating fields in my Android application. Using the Salesforce client, I populated some source data to develop the application in Android Studio. Below is a summary of the submitted values: Based upon the sample data, Finny always prefers ”Pizza” over “Chicken & Rice”. Adding Meal Functionality in Android Studio With the source object and data configured, I used my IntelliJ IDEA application to open the project for the first time. ./finnys-foods-android For simplicity, the source code for my Android application will exist in the file. Feature developers building business applications should consider adopting design principles for their Android applications. The “ ” article by the team provides some excellent information on this topic. ./android/MainActivity.java Organizing your Source Files CodePath The file was already populated with enough information to connect to Salesforce and make things quite easy to build upon. I first introduced a SOQL static string to house the simple query to access the : MainActivity.java Meal__c object private static final String SOQL = "SELECT Name, Rating__c FROM Meal__c ORDER BY Name ASC"; Instead of pushing a button to see data in the app, I updated the method to call the method to request data from Salesforce: onResume(RestClient client) sendRequest() @Override
public void onResume(RestClient client) {
  this.client = client;

  try {
    sendRequest();
  } catch (UnsupportedEncodingException e) {
    Toast.makeText(MainActivity.this,
	MainActivity.this.getString(R.string.sf__generic_error, 
         e.toString()),	Toast.LENGTH_LONG).show();
  }

  // Show everything
  findViewById(R.id.root).setVisibility(View.VISIBLE);
} I updated the method to not only retrieve data from Salesforce but to provide a visual representation of the rating for each item: sendRequest() private void sendRequest() throws UnsupportedEncodingException {
  RestRequest restRequest = RestRequest.getRequestForQuery(
                              ApiVersionStrings.getVersionNumber(this), SOQL);

  client.sendAsync(restRequest, new AsyncRequestCallback() {
    @Override
    public void onSuccess(RestRequest request, final RestResponse result) {
      result.consumeQuietly(); // consume before going back to main thread
      runOnUiThread(() -> {
        try {
          listAdapter.clear();
          JSONArray records = result.asJSONObject().getJSONArray("records");
          for (int i = 0; i < records.length(); i++) {
            listAdapter.add(records.getJSONObject(i).getString("Name") + " "
              + getRating(records.getJSONObject(i).getInt("Rating__c")));
          }
        } catch (Exception e) {
          onError(e);
        }
      });
    }
			
    @Override
    public void onError(final Exception exception) {
      runOnUiThread(() -> Toast.makeText(MainActivity.this,
                           MainActivity.this.getString(
                           R.string.sf__generic_error, exception.toString()),
                           Toast.LENGTH_LONG).show());
    }

    private String getRating(int rating) {
      switch (rating) {
        case 5:
          return "* * * * *";
        case 4:
          return "* * * *";
        case 3:
          return "* * *";
        case 2:
          return "* *";
        default:
          return "*";
      }
    }
  });
} For simplicity, I decided to show a five-star rating item using the asterisk symbol. So a five-star item will appear as shown below: Pizza * * * * * I added an issue to my GitLab repository to replace the asterisks with star-based icons—like those provided by Font Awesome—so that empty stars will display when the rating is less than a five. Introducing a Custom Text View Instead of relying on the default design of the component, I decided to create my own text view to display the data within the live view containing the list of meals in Salesforce. ListView Inside the folder, I created a new XML file, called and included the following information: ./app/res/layout custom_text_vew.xml <?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@android:id/text1"
    android:fontFamily="sans-serif"
    android:paddingTop="10dip"
    android:paddingBottom="10dip"
    android:paddingLeft="1dip"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textSize="9pt" ></TextView> I was able to set the font and placement information to match my expectations. With the XML in place, all I needed to do was reference the custom text view with the following update: listAdapter = new ArrayAdapter<>(this, R.layout.custom_text_view, new ArrayList<>()); Some Final Clean-Up and Styling Since I wanted to match the React Native version of my application, I made the following updates to the file: ./app/res/layout/header.xml <?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="match_parent"
	android:layout_height="100dp"
	android:layout_marginTop="5pt"
	android:layout_marginBottom="0pt"
	android:padding="3dp" >

	<TextView
		android:id="@+id/text_title"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:layout_centerVertical="true"
		android:text="@string/app_name"
		android:textSize="12pt"
		android:fontFamily="sans-serif"
		android:textFontWeight="600"
		android:layout_marginLeft="3dp"
		android:paddingBottom="0pt"
		android:paddingLeft="7pt"
	></TextView>

	<View
		android:layout_below="@id/text_title"
		android:layout_width="match_parent"
		android:layout_height="2dp"
		android:layout_marginTop="5pt"
		android:background="@android:color/darker_gray" ></View>

</RelativeLayout> Finally, I reviewed the file and removed all of the unused methods as a result of updating the header.xml file. Android Studio, like IntelliJ IDEA, is great at changing the color of unused method names, which can be removed without impacting the run-time functionality of the application. ./finnysfoods/android/MainActivity.java Finny’s Foods in Action Using Android Studio, I used the Run menu option and selected the option, which also maps to the shortcut. Run ‘app’ Shift-F10 First-time use will automatically redirect to a Salesforce login screen, where I used the same email address and password to access my Developer org. After signing in, the Finny’s Foods application appeared, including the five-star rating value for each item. In a matter of minutes, we were able to create an Android application using Android Studio and the Salesforce Mobile SDK. Conclusion In this article, I introduced a custom mobile application that deploys natively from the Android store and uses source code written in Java and basic XML. Along the way, we gained a basic understanding of how Android-based applications are structured. Starting in 2021, I have been trying to live by the following mission statement, which I feel can apply to any IT professional: “Focus your time on delivering features/functionality which extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” - J. Vester The Salesforce Mobile SDK certainly adheres to my personal mission statement, which will benefit any feature team that requires Salesforce functionality as part of custom mobile applications running on Android devices. Software engineers in this realm of development should certainly consider adding the Salesforce Mobile SDK as a project dependency. If you wish to see the full source code for this article, simply navigate to the following project on GitLab: https://gitlab.com/johnjvester/finnys-foods-android In the final article of the series, I plan to use the Salesforce Mobile SDK with xCode to create a native application for iOS devices. Have a really great day! Also Published Here

Using Android Studio to Explore the Salesforce Mobile SDK

I gradually woke to the warmth of Harry licking my lips, just frantically enough so I knew he needed to pee. It was three in the morning, cold and quiet. I hooked the leash to his collar and  we headed out into the night. I'd been unemployed since July and this was October. I'd been in online direct marketing for six years, becoming Creative Director, and in theory, I could go back to something like that. We sold 'cosmeceuticals' like wrinkle reducers and scent-based weight loss powder and did surprisingly well through rigorous A/B testing and a deep understanding of human laziness. It was a risk-free trial ...as long as you return your shipment in 30 days. The price to land each customer sometimes approached the cost of the product, but as long as 30 or 40 percent forgot to cancel their continuity, we'd bank a solid profit. --Oh, you didn't know it was a continuity program? Should have read the fine print, sucker. The difference between financial success and abject failure was around 1.5 shipments per customer. It was honest work, as long as your bar for honesty was just above wire fraud. We'd optimized the process into a ruthlessly profitable juggernaut, but who wants to wake up every morning to make the world just a little bit worse than the day before? Could wake up each day knowing the world would be better off if you didn't wake up? As fun as it sometimes was, and my bosses knew how to throw a decadent party, I got tired of shilling for the dark side and finally had to quit. you I could go back to school thanks to stock options money. But for what? I researched school psychology and genetic counselling, I could become a nurse practitioner or maybe a physician’s assistant. But then I talked to a friend who's a PA and she likes nothing more than assisting surgeries all day long, the bloodier the better. She bragged about holding a beating human heart in her hand like some Aztec priest. Nothing felt right, time was running out, and I could only tread water for so long before I'd have to go back to selling perfumes that could make you look ten years younger based on actual scientific data. I couldn't claim unemployment since I'd quit. But an actress friend told me a trade secret. Every show is its own job. As long as you have a decent income history, you can work once as an extra then qualify for unemployment after the shoot. That might buy me enough time to find my path. So I signed with Central Casting, a company that provides background workers to shows across the LA area. Unfortunately, so many people are either hoping for their big break or else can't stomach manual labor that call lines tend to max out the second a job is posted. It took a lot of patience and effort, but eventually, I landed the role of 'wealthy patron' at a late-night tiki bar, in the background of , starring Zoey Deschanel. The timing was perfect because the very next day I'd arranged to shadow a clinician in South Pasadena. After flipping through a dozen possible careers, I'd landed on Speech-Language Pathology. It was science-based, could be achieved after a few years of college, and best of all I could wake up every morning with the knowledge I was actually going to help people improve their lives. I'd already ordered a set of cranio-facial flashcards and begun memorizing the bones of the skull. The New Girl First, of course, I needed that bi-monthly unemployment check, so two days later I pulled into the Fox parking garage in my finest bar crawl gear with my only good suit in a garment bag. stage was a massive warehouse with its interior partitioned off into sets. There were maybe 30 extras slouching on folding chairs or rolls of carpet in an area walled off on the left and right by the sort of painted flats seen through the window of a situation comedy. Varying levels of hope and desperation were on display, from empty nest housewives to absurdly attractive 20-somethings trying to make a few bucks between auditions. But there was a sad, resigned quality to it all, as if we were just waiting for a flight to some industrial town for a contractually obligated visit. The New Girl Keep in mind these people get minimum wage, they arrive early, stay late, are often asked to bring specific items like dry-cleaned suits or musical instruments to the set, and the majority of their day is spent sitting in a cold dim warehouse in group isolation. Most importantly, there is absolutely zero chance this experience will result in any sort of acting career. You'd be better off driving around town with 'Cast Me!' spray-painted on the side of your van, which Dennis Woodruff did years ago to limited success. Background work is menial labor wrapped in the mind-numbing boredom of a waiting room, loosely held together by the thinnest tissue of show-biz. It's purgatory with a paycheck. And so we waited, for what felt like a full working day, as I memorized terms like 'Anterior nasal spine' and 'Zygomaticofacial formen'. Hours later, a background wrangler brought us onto the brightly lit set of a tiki bar, to be arranged in clumps of two to four. Our job was to hold elaborate tropical drinks, not look at the cameras, and pretend to have interesting conversations while the actors spoke their lines. They placed me in a far corner facing an oddly placid woman, and I smiled at her pantomimed repartee as the show's male star mused with his friends about the emotional repercussions of an upcoming pub crawl. The cast and crew and even the extras were patient and professional, and I couldn't help wondering what it would be like to wake up every morning to work insanely long hours creating mildly interesting commercial delivery mechanisms that people watched while eating their dinners on the couch. Would that be enough to live your life without regrets? The setups moved at a glacial pace, and after an hour even my fake conversation began to run dry. Eventually, I fell back on the usual nervous tics --nodding, grinning sheepishly, taking long slow sips of my drink --at which point I remembered they didn't make me a drink. They'd poured tap water into a tiki mug without washing it out. Suddenly I had a mouthful of drywall runoff and spackle. My partner reacted to the panic in my face as I realized you can't spit up brown sludge in front of the cameras; they'd fire me in an instant and I'd never get unemployment. The lady touched my shoulder with concern as I tried desperately not to projectile vomit across her teal party dress, before finally choking down the gack with a grimace. Hours later, wandering the deserted lot during our nighttime lunch break, I realized there was no way the coffee I'd been pounding could power me through the next 10 hours of the shoot. This is why, to maintain energy and focus, I swallowed a couple of psychedelic mushrooms. They were medicinal, brought as a metabolism booster in case of emergency, and I quickly forgot I'd even taken them. Until about an hour later during the climactic scene at the tiki bar. We're standing silently, inches away from each other in our club crawl finery, trying not to meet each other's eyes as camera people tinker with something at the bar. A dapper Filipino guy in a bow tie mocks me for eating the fruit décor of my tiki drink --which, to be fair, we'd been explicitly and repeatedly asked not to do by the support staff. And in that instant of self-awareness, some combination of caffeine, hunger, and psilocybin combines to wake me to our reality like a slap in the face. You should remember, 'hallucinogen' is a misnomer. You don't see things that aren't there, you see things that were there the whole time that you've trained yourself not to see. Anything beyond a microdose and preconceptions fall away, all that pigeonholing of reality into conceptual chunks like inartfully translated poetry. Things like psilocybin let you bypass the cognitive shorthand you've learned since birth in order to deal with this nonsensical cathedral of human culture we've trapped ourselves in. I'm looking around wide-eyed and innocent. Somehow, needing to change careers has resulted in me standing here with thirty strangers in the night, packed shoulder to shoulder in a high-walled pen, solemnly ignoring each other's blank yearning faces while lights and cameras glare down from the fake walls of a fake bar decorated in a fake vision of Polynesian culture. We're being paid a small amount of money to pretend to be human beings —and isn't that just a metaphor for what being a human being is?! I take a drink from my mug and thank god this time its pineapple juice. Then someone yells 'background!', and time lurches into motion. There's me, that smartass with the bow tie, a proud grandmother of four and a brunette woman in an evening dress who's giving off 'swinging divorcee' vibes. But as I give in to the motions of pretending to relate to them, silently smiling and laughing, the anxiety melts away. One by one I look deep into their eyes and see through to the core of each person's soul. The shot involves what I think is a famous Wayans brother, playing a disgruntled pickup artist on Valentine’s Day. He tries to liven the scene with a few ad libs, which noticeably improves the dialog. Later, as we head back to the waiting area, an efficient-looking man in a Bluetooth headset taps me on the shoulder, shaking his head, wagging a finger. "We see what you're doing there guy." I'm pretty sure he was referring to the moment in the final shot when our grandmother silently told a joke and the irony of actually laughing at a pretend joke created a humor feedback loop that gave me stomach cramps as I tried so desperately not to laugh out loud that I almost fainted. He thinks I was showboating for attention, so I nod to reassure him it won't happen again, and we head to the portable dressing rooms to suit up. For the last half of the day, we'll be diners at a fancy restaurant. I walk out in my best wedding outfit and the wardrobe lady with a straight face tells me she likes my weird, quirky look. Before long we're gathered around picnic tables on the lawn near the stages and I'm watching James, the smartass with the bowtie, teach a regular from Sons of Anarchy how to tie a Windsor knot. It turns out James came from the Philippines six years ago to work in LA as a nurse. But he's already burned out from the hospital politics and the gruelling hours and thankless doctors. He's in the middle of a career transition himself, probably real estate. It's after midnight now, moonlight glinting on the rustling Magnolia branches in the silence of the empty lot, and it's clear that is some kind of modern-day bardo, the Buddhist realm between death and rebirth. Forty well-dressed souls in limbo, lit by the midnight moon, transitioning between lives or else waiting for this one to end. Our conversation drifts into philosophy and James tells me about the new age guru Eckhart Tolle with such eloquence that I order his book from Amazon then and there. The New Girl Soon the wranglers pair us off into male-female dyads. I take the elbow of a beautiful blonde in a black evening dress and we stroll down the sidewalk toward a building in the distance, not knowing each other or where exactly we're headed. Everything is a metaphor now. Her name is Susan and she just arrived from six months in Korea with her husband. We find ourselves in an immense dining room, sitting across from each other at a beautiful meal we're not allowed to eat (more metaphor!), while Zoey Deschanel and some handsome Euro-accented fellow with a well-trimmed beard film their dinner scene. We're far enough away to have a real conversation and I grill Susan about her life in Korea. She and her husband taught, explored the world, and are ready for the next stage of their lives. To take that leap into darkness confident the universe will catch you —I'm in awe. I get so engrossed in the conversation that for a good half hour I forget we're on a set. Eventually, the director decides we're distracting and removes our table, then around 4:30 in the morning, the pack of us are brought outside to slowly walk back and forth outside the window of the dining room to appear as blurry shapes behind Zoe's conversation. It's the last stage before rebirth, just flickering shadows at the edge of someone else's consciousness, and I'm so jazzed to begin my new life that I'm not even tired anymore. The day ends near 5 am, and a few cups of coffee later I'm heading up the 110 Freeway to begin learning what it means to be a Speech-Language Pathologist. Elisa was a wise and friendly professional who took me back through the elementary school where she worked to her office. And in half an hour I realize no way am I going to be a Speech-Language Pathologist. It's not that I don't like children. They're fine. I understand they're necessary. I just didn't fully comprehend how they'd dictate the entire workday. Elisa had an encyclopedic knowledge of how the physicality of the skull works to create sound, but she utilized that expertise eight hours a day playing speech games with seven-year-olds while taking notes about how they pronounce words like 'the.' My guess is, if you have strong parenting instincts this sort of thing isn't excruciating. But when I left that afternoon full of effusive thanks for her patience and generosity, Elisa could tell she would not be seeing me at any SLP conferences in the distant future. I was back in the bardo with no prospect for rebirth. But then, out of the blue, a call comes through from the human resources manager I used to work with. She wants to know if I'm interested in a hot new social media startup in Downtown LA. All she'll say is their name -- . Vixlet The next day an elevator rockets me silently to the Gas Company building's 50th floor. The view out the windows looks like you're landing at LAX. The company is owned by a husband and wife team and she walks into the conference room with a small entourage, lead by a new media guy named Justin who looks exactly like the person who'd play him in a commercial. Seek, coiffed, black glasses signifying intelligence. He scans me head to toe: Camper shoes, Ben Sherman shirt and jacket, Warby Parker glasses. I sense the tiniest acknowledgement, as if I've passed the minimum bar for acceptability. Everyone other than the boss looks like they've just graduated from one of those East Coast colleges you only know about if you're rich. We sit at an empty table and he gives me the spiel. Vixlet is a revolutionary new form of social media. They've got millions in the bank, and they literally want to take on Facebook. I keep waiting to show my work, but no one asks. They don't want me for design or user experience. They're starting a new Product Department that will somehow connect design and development, or give them direction, or something. I try to get more detail, but they're intentionally vague. After deflecting a few questions, a hyper-literate 20 year old tells me people succeed at this company if they’re able to adapt to a constantly changing environment. I get the hint and stop asking, even though I have no idea what skillset they're looking for. Eventually, they march out in unison like the East German swim team, and the head of the company makes an entrance, a hefty subcontinental Indian man with a magnetic personality and the voice of James Earl Jones. I stand as he takes my hand, doesn't let go, and looks deep into my eyes through to the very core of my soul. His name is Krishna. "You tell me, Randy," he says after a brief introduction, "when did social media begin?" It's clearly a rhetorical question, but he still wants an answer. "I don't know... Friendster?" "No. Randy." Still holding my hand. "More basic than that. Thousands of years before that, in fact, when that first human hand grabbed a bone and struck that first drum. That's social media. Communication!" It's clearly a prepared speech but he's good at it. Krishna fast forwards through the evolution of human interaction to this new, completely unprecedented developmental stage in the process that he alone has discovered --passion-based social media. Science tells us that the average American has over 50 passions; that's what'll connect us in the future, not the rough simulation of real world 'friendship' that Facebook offers. He talks about the insane growth hacking they're ready to begin, beating Facebook before they even know what happened. To be clear, I worked in online direct marketing so I know when someone's blowing smoke up my ass. But this was the first time I actually liked it. Somehow that recommendation from the head of human resources short-circuited the process. No one had ever hired me without looking at my work. --And who's to say they wouldn't change the world? I was employed by the company that made MySpace and they went from a few people in a row of cubicles down the hall to a $580 million dollar payout in just a few years on the backs of obsessive preteens without any design sense. Krishna asks me how much I'd need in order to walk to work skipping and singing every morning, and I tell him my previous salary. He stares into my eyes for a long while. “Randy. I believe we have a disconnect.” Eventually, Krishna hires me for thirty thousand less, with vague promises of stock options, but it doesn't matter because he's given me hope for the future. I'd emerged from darkness into a new career. It's not until a week later when I hear someone talking about me that I realize my title: Product Manager... Three years after that we're called to an 11 am meeting. I get a text from my friend Steve letting me know they'd deposited our paychecks early. "Looks like the new round of funding finally came through!" But the moment Krishna walks into the room I can tell it's over. He's genuinely heartbroken and seems ready to cry. "Take all the time you need." He bites his lower lip, either holding back tears or giving a very believable performance. "But make sure you turn in your laptops, as we no longer own them." I'd been a Product Manager for three years at that point and (arguably) been good at it for maybe a year and a half. After just a few months the head of the department left for Google when he realized the relentlessly hapless shitshow he'd signed up for, the new head of the department was fired for harassing the designers, one PM left for a better job and another moved to a different position in the company. I was the last PM standing. I had not in any way made the world a better place to live, but had almost certainly made it less bad than I would have, promising women they could look ten years younger through regular applications of cetacean placenta juice. Despite what they'd paid McKinsey a small fortune to tell us, we had a fundamentally flawed business model. Turns out virality is not a top-down phenomenon. At the end of the day, Vixlet was the startup equivalent of a secondhand Volkswagen piloted by a pack of bickering raccoons from on top of a mountain of investor cash. At first, it felt like we had a direction, but we were just careening downhill, finally slamming after a few short years into the desert hardpan below. It only cost me one minor heart attack (that turned out to be a panic attack), and constant low-level frustration and dismay, but after three years I'd developed a very particular set of skills that perhaps now I could put to good use.

How I Went from the Set of New Girl to a Startup Product Manager

It’s no surprise that scientists continue to reinvent already established technologies. The question may not be how, but type of green technology will remain relevant years down the road? what With Global Warming and other environmental issues plaguing our planet, many scientists are working on alternative sources to replace current energy sources and take care of environmental damage caused by past fuel use. While some older efforts have been successful, developing countries still use previous generation fuels at a high percentage rate. Green Technology has become an emerging trend in areas worldwide where gasoline prices have reached an all-time high. Electric vehicles have seen a significant increase in sales due to environmental awareness, while companies like Tesla are working on making electric cars the new trend. A Sustainable Technology — Economically, Ecologically, And Socially With an increasing number of technologies making their way to the market, they're not all as innovative as they may seem. Electric cars, for instance, have been around for more than a hundred years but were inspired by steam engines. Some green technology that has struggled from the start is solar panels due to their high price and inefficient energy collection capabilities. One way to make green technology profitable is by making a product that people want and need. A good example would be Tesla's electric cars which are extremely popular among many different age groups because they offer a sleek design without sacrificing safety features or storage space. This reason alone contributes to the motivation behind going green. It allows families with children to travel in comfort while having quick access to strollers and other belongings. Environmentally-Friendly Business Ideas The demand for environmentally friendly products is on the rise. With this, people are seeking out ways they can help protect our planet and create businesses that support those goals! You could open your own green company by offering services or selling eco-friendly items like organic produce. There are many ways for you to go green in your business. Some of them might be more effective than others, but these 10 examples show that it can really work!: 1. Sustainable construction materials Construction is one of the biggest industries in the US. The construction industry is responsible for creating nearly 4 billion metric tons of waste each year, accounting for 40% of all non-hazardous solid waste produced in the country. Just imagine if you could change this! There are several sustainable building materials that you can use to build homes, offices, factories, and more while being good to the environment! These include recycled steel rods, scrap wood beams, bamboo floors, cork wall coverings, marine plywood panels, and many more! 2. Eco-consulting Consulting on how to be more environmentally friendly is another great way to go green. Many people want to help protect the environment, but they don't know where to start! With your knowledge and experience in the field, you could consult businesses about improving their environmental impact without too much hassle or cost. Startups like Climate Coach give businesses information on how to succeed with green projects. 3. Eco-friendly Fashion With an increase in awareness about the harmful effects of clothes made with synthetic materials, there has been a surge of companies selling clothes made from organic fabrics instead. It might seem like it's too expensive to be sustainable. However, many of these companies have found ways to make their products affordable while still using ethical methods. Startups like , a Swedish jeans maker, offer various recycled denim materials to make the jeans. Nudie 4. Organic food Organic food is one of the most popular trends in the US right now. Many studies have shown organic foods are healthier for you, but why do people buy them? Many clients choose to purchase organic produce because they want to minimize their environmental impact. Organic produce has fewer chemicals on it, which means it takes less water and energy to grow. 5. Eco-friendly cosmetics If you've ever thought about opening up your own beauty supply store, selling products made with natural ingredients could be a great way to go green! You don't need any fancy degrees or certifications — just a passion for going green and a drive to make a difference! You could sell beauty products like organic shampoo and conditioners, make your own non-toxic nail polish, promote eco-friendly sunscreen, and more! 6. Reusable Bags/Produce Bags Did you know that plastic bags can take up to 1000 years to decompose? Not only does this take up space in landfills, but the chemicals found in plastic bags can leach into our soil and water, which can lead to damage on all levels of the food chain. This is why reusable grocery bags are so important! You could use them as a means of advertising or even offer them for free with certain purchases. This would promote sustainable living while increasing your business' profits! 7. Planting Trees Planting trees can be very beneficial to the planet in many ways! It helps reduce greenhouse gases, creates oxygen for us to breathe, reduces water runoff and erosion, protects animals from natural disasters, and supports sustainable livelihoods. Not only could you plant trees on your own property or even in your neighborhood, but you could also sell tree saplings at affordable prices so that others may have the opportunity to do the same! Startups like , Tree-Nation, and Acorn, have already built their businesses around tree planting, so consider looking into this if your aim is to help protect the environment. Verdoo 8. Eco-friendly Cleaning Products Making eco-friendly cleaning products doesn't have to be expensive or difficult! Many companies are switching to plant-based or mineral cleaning agents because they are less harmful to our environment. You could do the same by using organic palm oil instead of petroleum jelly for homemade goods like lip balm or candles. You could also use plant-based soap for your cleaning supplies. 9. Recycling/Repurposing/Upcycling Recycling is one of the easiest ways to go green! It takes about 95% less energy to reuse products instead of using new raw materials every time you make something. You could even start your own business by purchasing used items from stores or individuals and reselling them for a profit! This doesn't only include clothes, but electronics, furniture, sporting equipment, and more! 10. Implementing sustainable business practices The easiest way to start going green is to look at how you can improve your own business! There are many ways that businesses can go green without being too expensive. Businesses that manufacture products could begin using sustainable packaging or print their logo on biodegradable packing tape instead of plastic bags. You could also focus on making eco-friendly storefronts by replacing glass windows with bamboo blinds, for example. You could even sell wind chimes made out of recycled materials, so customers know they're shopping at a sustainable store! Conclusion There are many different things you can do to go green and help save our planet! Some of them include growing your own food, recycling old products, using eco-friendly cleaning supplies, planting trees, and more! Remember that going green doesn't have to be difficult. All it takes is a few small steps in the right direction to make a huge difference for future generations.

10 Eco-Friendly Business Ideas for Sustainability-Minded Startups

In an era of rapidly changing technology and unexpected global catastrophes, the greatest challenge facing the insurance industry is its ability to keep up with consumer demand while being weighed down by its legacy. In February, Sophia Yen, EY Americas Insurance Strategy & Innovation Leader, wrote, "insurers experienced more change in the last 10 months than they had in the previous 10 years, with important shifts across the business. Many were long overdue and set the stage for a more disruptive future." EY had “found that the insurance industry has created only five new product classes during the last 30 years.”  There was now a need for insurers to reimagine “product development around the emerging needs of customers. To design better solutions, they must be systematic about embedding customer insight into product innovation.” According to Capgemini’s World Insurtech Report 2021, today's insurance customer wants what Capgemini dubbed its CARE equation: convenience, advice, and reach. The insurance industry is supported by decades-old technologies designed with proprietary code which cannot readily plug into many new eco-systems or interact with external interfaces. We have all seen how frustrated product managers become attempting to respond quickly to an opportunity, a crisis, or even regulatory changes on legacy systems. The costs and time required are serious limitations to innovation. Life Insurance and other long-term products are often quite complex, requiring complicated rules and transaction management. A product may have been created on a legacy system more than 20 years ago, the time and effort needed even to adapt to changing regulations becomes a real issue. Things are even more difficult when trying to meet the expectations of digital servicing for clients whose policies sit on these systems. As it stands, the insurance industry faces four critical operation issues moving forward with legacy systems: A diminishing pool of IT talent for maintenance and support results in increased costs. Decreasing support from system vendors, thereby threatening business continuity. Operational errors due to a lack of digital integration and manual data entry. The ever-increasing demands of regulatory compliance. How to Respond Insurers generally handle the legacy system issue in a predictable way, with the choices often boiling down to variations on refactor, replace, and preserve, and runoff: Refactoring is basically removing complex middle layers of the technology environment, sometimes unbundling some business process functions while leaving the central core. Preservation and run-off mean to wrap legacy systems with a new layer of modern technology to introduce new functionality or interactions while allowing the closed book of business to run itself off without adding any new business. It requires in parallel the introduction of a new greenfield system to handle new products and new business sales. Replacing the systems altogether, whether it is done in a Big Bang or as a phased approach, is often very expensive and risky, involving complex data mapping, transformation, and migration efforts that can take years to complete. A Better Way Ignatica helps insurers meet consumers’ demands with the minimum of business disruption. Our technology and methodology are tailored to our clients' needs. New products can be created, tested, and brought to market within days on our platform, which is designed to coexist side by side with the current legacy. As clients look to retire their legacy systems, we offer an efficient and low-risk approach to product migration that minimizes risk and improves time to value. A lot of opportunities are being left on the table, not because the concepts are unproven, or the risks are not understood, but because the price of implementation and the cost of administration is so huge insurers are forced to leave segments untouched and products not launched. Ignatica is confident that our suite of SaaS platform modules across product definition, policy admin, and data intelligence is extremely effective in responding to each market need and the challenges ahead. By Manuel San Miguel, CEO, and Co-Founder, Ignatica Manuel San Miguel is the CEO and Co-Founder of Ignatica, the SaaS core insurance platform which allows insurers to quickly launch products and automate their business operations. An insurance industry veteran in Asia, he is the former CTO for Manulife.

The Insurers' Dilemma: Balancing Consumer Demands and Legacy Conventions

As part of my personal development, I've created a personal health platform that uses various different microservices (Built using Azure Functions) that extract data from my Fitbit account and store them in an Azure Cosmos DB database. I have other microservices that pass messages between different services via Azure Service Bus. For this project, I use Azure DevOps to build my artifacts, run my unit tests and deploy my microservices to Azure. The great thing about DevOps is that we can do all of this within the YAML pipeline. Yes I said YAML. Honestly, I don't know what the fuss is all about 😂 In a previous post, I talked about how we can deploy NuGet packages to a private feed in Azure Artifacts using YAML pipelines. If you haven't read that post yet, you can check it out below! https://dev.to/willvelida/publishing-nuget-packages-to-a-private-azure-artifacts-feed-with-yaml-build-files-3bnb In this article, we will turn our attention to building and deploying C# Azure Functions using a single build file. What we'll cover We've got quite a bit to cover, so I'll break down my YAML file and talk about each stage in the following order: Triggering a Build 👷‍♂️👷‍♀️ Using User-Defined Variables in our pipelines 👨‍🔬👩‍🔬 Defining Stages 💻 Building our project 🔨 Running our tests 🧪 Getting code coverage 🧾 Producing a Build Artifact 🏠 Using Secrets from Key Vault 🔑 Deploying our Function to Azure ⚡ Running our build pipeline 🚀 Triggering a Build 👷‍♂️👷‍♀️ In our build pipelines, we can use triggers to run our pipelines. We can use different types of triggers, ranging from triggering a build when we push our code to a defined branch, to . scheduled triggers based on a CRON schedule For this project, I'm just triggering my build every time I push to the main branch. To do so, I define this in my YAML file like so: trigger:
  - main Now if I wanted to do this properly, we could define multiple branch names to trigger builds from like so: trigger:
  - feature/*
  - bugfix/* This would trigger the builds when we push code to either our feature or bugfix branch. When we raise Pull Requests in DevOps, we can create policies on our PR to only be eligible to merge back into our main branch provided that the build was successful. This helps us increase our confidence that the code we are merging (and deploying) is of high quality, particularly if we are running tests as part of our build pipeline. To enable build validation on your branch policies, check out this documentation Using User-Defined Variables in our pipelines 👨‍🔬👩‍🔬 We can use user-defined variables in our YAML files to use throughout our pipeline. Doing this gives us the benefit of re-using common values across various stages and tasks in our pipeline, and it allows us to track changes to them over time using version control. We can define variables within out file with the following scope: , making it available to all jobs in our pipeline. At the root level , making it available to a specific stage in our pipeline. At the stage level , making it available to a specific job in our pipeline. At the job level In my case, I'm going to be re-using these variables throughout my pipeline, so I'm defining them at the root level. variables:
  buildConfiguration: 'Release'
  vmImageName: 'vs2017-win2016'
  functionAppName: 'famyhealthfitbitbody'
  azureSubscription: '<azureSubscription-id-or-name>'
  workingDirectory: '$(System.DefaultWorkingDirectory)/MyHealth.Fitbit.Body'
  projectName: 'MyHealth.Fitbit.Body' We're not just limited to user-defined variables in YAML pipelines! We can use System and Environment variables as well. To learn more about defining variables in YAML pipelines, check out this article Defining Stages 💻 Within our YAML pipelines, we can organize our jobs into Stages. These divide our pipeline into logical....well, stages that perform certain tasks, such as 'build the app', 'deploy to production'. In this example, I just have a stage and deploy stage. Every YAML pipeline has at least one stage even if we don't define it. As I have done in my file, we can also run stages depending on whether the previous stage has succeeded or not, like so: stages:
  - stage: Build
    displayName: Build Stage

    jobs:
      - job: Build
        displayName: Build MyHealth.Fitbit.Body
        pool:
          vmImage: $(vmImageName) Using YAML pipelines, we can define multiple stages of our pipeline and store it as code. Check out the if you want to learn more about how Stages work in YAML pipelines. documentation Building our project 🔨 Let's turn our attention to our Function. First up, I want to restore and build my .csproj files. In our YAML pipelines, we can se .NET Core tasks to run dotnet commands against our artifacts. To build my project, I'll and . restore build I'm using a custom NuGet feed hosted on Azure Artifacts, so I will need to point to this feed when restoring. For the build task, I want to build a release package, so I'll pass in the variable as an argument when running the command. buildConfiguration build For both commands, I'm going to point to all .csproj files in my repository. steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
   command: 'restore'
   feedsToUse: 'select'
   vstsFeed: '<feed-id>'
   projects: '**/*.csproj'
    
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
   command: 'build'
   projects: '**/*.csproj'
   arguments: --configuration $(buildConfiguration) Running our tests 🧪 Alongside my function code, I have a project for my Unit Tests. As part of my build, I want to run my unit tests to make sure that my changes haven't broken any of our tests and that they still pass. If any of my tests fail, I want the build to fail. To run our tests, we can use a .NET Core task that runs the command and point the task at our Unit Test .csproj file. test I also want to collect code coverage metrics with Coverlet. Coverlet is .NET tool that allows us to get unit test coverage for line, branch and method coverage. In our arguments parameters, I'm telling my task to run Coverlet to get the code coverage and then publish the test results to the */TestResults/Coverage folder on my build agent: - task: DotNetCoreCLI@2
  displayName: Run Unit Tests
  inputs:
   command: 'test'
   projects: '**/*UnitTests/*.csproj'
   arguments: '--configuration $(buildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura /p:CoverletOutput=$(Build.SourcesDirectory)/TestResults/Coverage/'
   publishTestResults: true Getting code coverage 🧾 Once we've generated our coverage report, we can publish it to see the results. I've got two tasks within my pipeline to achieve this. First, I'm using a bash script task to install the report generator onto the Build agent. Once that's installed, I'm creating the xml report into my TestResults/Coverage folder on the agent. We can also specify the report type that we want to generate, but for this tutorial I'm just generating an inline HTML report. If you want to use a task for this instead of running an inline script, you can try installing the following onto your DevOps organisation. task Once we have generated a report, I've got a second task that publishes the code coverage report. - script: |
    dotnet tool install -g dotnet-reportgenerator-globaltool
    reportgenerator -reports:$(Build.SourcesDirectory)/TestResults/Coverage/coverage.cobertura.xml -targetdir:$(Build.SourcesDirectory)/CodeCoverage -reporttypes:HtmlInline_AzurePipelines;Cobertura
    displayName: Create Code coverage report
  
- task: PublishCodeCoverageResults@1
  displayName: 'Publish Code Coverage'
  inputs:
    codeCoverageTool: Cobertura
    summaryFileLocation: '$(Build.SourcesDirectory)/**/coverage.cobertura.xml'
    reportDirectory: '$(Build.SourcesDirectory)/TestResults/Coverage/' When our build finishes, we can review our code coverage report within DevOps! It should look similar to this: Producing a Build Artifact 🏠 We've built our project and our tests pass! We now need to produce a build artifact that we will deploy as our Function. Starting with publish, all we need here is a .NET Core task that runs the command, publishes our project as a 'Release' package, zip it and then publish it to our Artifact Staging Directory on our build agent. publish We then use a to publish an artifact called 'drop' into our staging directory. Publish Build Artifact task - task: DotNetCoreCLI@2
  displayName: Publish
  inputs:
    command: 'publish'
    publishWebProjects: false
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration) --output $(build.artifactstagingdirectory)'
    zipAfterPublish: True
            
- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact'
  inputs:
    PathtoPublish: '$(build.artifactstagingdirectory)' Just a mini-recap before we move onto deployment. In our Build Stage we have: Built our .NET Projects Run our Unit Tests to ensure our build is a quality build Generate and publish a code test coverage report. Publish a build artifact to deploy to Azure. With that achieved, we are now ready to move onto our deployment stage! Deploying our Function Stage For our deployment stage, we'll need to create a new stage in our YAML file. In this case, I've added a and property to our Stage YAML block. In the YAML file, I'm saying that the 'Deploy' stage our 'Build' stage and that the 'Deploy' stage will only run on the condition that the 'Build' Stage has succeeded. condition dependsOn depends on - stage: Deploy
    displayName: 'Deploy MyHealth.Fitbit.Body'
    dependsOn: Build
    condition: succeeded()

    jobs:
      - deployment: Deploy
        displayName: Deploy MyHealth.Fitbit.Body
        environment: Production
        pool:
          vmImage: $(vmImageName) When we use multiple stages in a pipeline, they will run in the order that we define them in the YAML file. We can add dependencies to our stages using the parameter. dependsOn We can control which stages run by specifying the condition of that Stage. In my case, I'm stating that the 'Deploy' stage will only run provided that the 'Build' stage has run successfully. To learn more about how conditions work in YAML pipelines, check out the following . documentation Using Secrets from Key Vault 🔑 In my function, I'm doing performing a variety of tasks such as sending messages to Service Bus Queues and Topics, calling APIs using Access tokens etc. etc. In order to make these operations, I need to use connection strings and secrets that I'm storing in a Azure Key Vault. Because these are secrets and I don't want to expose them, I need to use a Azure Key Vault task within my pipeline. For this purpose, I can use the to download the secrets I need. Azure Key Vault task As a pre-requisite for this task, I need to create a that's linked to my Azure Subscription and I need a Key Vault that contains my secrets. Azure Resource Manager service connection Once I have this setup, I can use the following snippet in my pipeline: steps:
  - task: AzureKeyVault@1
    inputs:
      azureSubscription: '$(azureSubscription)'
      KeyVaultName: '<key-vault-name>'
      SecretsFilter: '*'
      RunAsPreJob: false Here, we are defining the subscription that contains our Key Vault with our secrets, and we are retrieving all of the secrets in our Key Vault. We could filter these out to use a comma-separated list of the secret names we want to download, but for now I'm just downloading everything. Deploying our Function to Azure ⚡ We're finally ready to deploy our Function! ⚡ For this I'm going to use a Azure App Service Deploy Task We can use this task to deploy a variety of different app service types, but in my YAML snippet, I'm specifying as our type. functionApp As a pre-req for this task, you'll need an App Service instance to deploy your code to. I'm also passing the package that we built earlier as our , using the variable for the name of our Function and then passing in key-values for our App Settings. I can pass in the secrets I need for my Function since we downloaded them in our Key Vault task. package $functionAppName - task: AzureRmWebAppDeployment@4
  displayName: 'Deploy Azure Function'
  inputs:
    azureSubscription: '$(azureSubscription)'
    appType: functionApp
    WebAppName: $(functionAppName)                   
    package: '$(Pipeline.Workspace)/drop/MyHealth.Fitbit.Body.zip'
    appSettings: '-FUNCTIONS_WORKER_RUNTIME "dotnet" -FUNCTIONS_EXTENSION_VERSION "~3" -KeyVaultName "<key-vault-name>" -AccessTokenName "<secret-name>" -ServiceBusConnectionString "$(<secret-value>)" -APPINSIGHTS_INSTRUMENTATIONKEY "<some-key>" -ExceptionQueue "myhealthexceptionqueue" -BodyTopic "myhealthbodytopic" -WEBSITE_TIME_ZONE "New Zealand Standard Time"'
    enableCustomDeployment: true
    RemoveAdditionalFilesFlag: true Our full YAML file Before we finish, here's my full YAML build pipeline: trigger:
  - main

variables:
  buildConfiguration: 'Release'
  vmImageName: 'vs2017-win2016'
  functionAppName: 'famyhealthfitbitbody'
  azureSubscription: '<azureSubscription-id-or-name>'
  workingDirectory: '$(System.DefaultWorkingDirectory)/MyHealth.Fitbit.Body'
  projectName: 'MyHealth.Fitbit.Body'

stages:
  - stage: Build
    displayName: Build Stage

    jobs:
      - job: Build
        displayName: Build MyHealth.Fitbit.Body
        pool:
          vmImage: $(vmImageName)
        
        steps:
          - task: DotNetCoreCLI@2
            displayName: Restore
            inputs:
              command: 'restore'
              feedsToUse: 'select'
              vstsFeed: '<artifact-feed-id>'
              projects: '**/*.csproj'
    
          - task: DotNetCoreCLI@2
            displayName: Build
            inputs:
              command: 'build'
              projects: '**/*.csproj'
              arguments: --configuration $(buildConfiguration)

          - task: DotNetCoreCLI@2
            displayName: Run Unit Tests
            inputs:
              command: 'test'
              projects: '**/*UnitTests/*.csproj'
              arguments: '--configuration $(buildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura /p:CoverletOutput=$(Build.SourcesDirectory)/TestResults/Coverage/'
              publishTestResults: true
  
          - script: |
              dotnet tool install -g dotnet-reportgenerator-globaltool
              reportgenerator -reports:$(Build.SourcesDirectory)/TestResults/Coverage/coverage.cobertura.xml -targetdir:$(Build.SourcesDirectory)/CodeCoverage -reporttypes:HtmlInline_AzurePipelines;Cobertura
            displayName: Create Code coverage report
  
          - task: PublishCodeCoverageResults@1
            displayName: 'Publish Code Coverage'
            inputs:
              codeCoverageTool: Cobertura
              summaryFileLocation: '$(Build.SourcesDirectory)/**/coverage.cobertura.xml'
              reportDirectory: '$(Build.SourcesDirectory)/TestResults/Coverage/'
    
          - task: DotNetCoreCLI@2
            displayName: Publish
            inputs:
              command: 'publish'
              publishWebProjects: false
              projects: '**/*.csproj'
              arguments: '--configuration $(buildConfiguration) --output $(build.artifactstagingdirectory)'
              zipAfterPublish: True
            
          - task: PublishBuildArtifacts@1
            displayName: 'Publish Artifact'
            inputs:
              PathtoPublish: '$(build.artifactstagingdirectory)'
  
  - stage: Deploy
    displayName: 'Deploy MyHealth.Fitbit.Body'
    dependsOn: Build
    condition: succeeded()

    jobs:
      - deployment: Deploy
        displayName: Deploy MyHealth.Fitbit.Body
        environment: Production
        pool:
          vmImage: $(vmImageName)

        strategy:
          runOnce:
            deploy:
              
              steps:
                - task: AzureKeyVault@1
                  inputs:
                    azureSubscription: '$(azureSubscription)'
                    KeyVaultName: '<key-vault-name>'
                    SecretsFilter: '*'
                    RunAsPreJob: false

                - task: AzureRmWebAppDeployment@4
                  displayName: 'Deploy Azure Function'
                  inputs:
                    azureSubscription: '$(azureSubscription)'
                    appType: functionApp
                    WebAppName: $(functionAppName)                   
                    package: '$(Pipeline.Workspace)/drop/MyHealth.Fitbit.Body.zip'
                    appSettings: '-FUNCTIONS_WORKER_RUNTIME "dotnet" -FUNCTIONS_EXTENSION_VERSION "~3" -KeyVaultName "<key-vault-name>" -AccessTokenName "<secret-name>" -ServiceBusConnectionString "$(<secret-value>)" -APPINSIGHTS_INSTRUMENTATIONKEY "<some-key>" -ExceptionQueue "myhealthexceptionqueue" -BodyTopic "myhealthbodytopic" -WEBSITE_TIME_ZONE "New Zealand Standard Time"'
                    enableCustomDeployment: true
                    RemoveAdditionalFilesFlag: true Running our build pipeline 🚀 We've successfully created a build pipeline in YAML that will be triggered every time we push to our branch. We can view the status of our build in Azure DevOps, which looks like this: main As you can see at the bottom of the image, we can see the result of each stage within our pipeline. If a particular stage had failed, we could use this to re-run a particular stage instead of having to push our code again to . main Wrapping Up Multi-Stage Build pipelines are awesome for defining our build and release process all within the same file. By using source control, we can track changes to our build process over time. We can also do useful things like generate and publish code coverage reports, download secrets from key vault and deploy apps all within one file! Hopefully, you found this article useful! As always, if you have any questions, feel free to comment below or ask me on ! Twitter Happy Coding! 💻👨‍💻👩‍💻 Also published on: https://dev.to/willvelida/building-and-deploying-c-azure-functions-using-multi-stage-pipelines-in-azure-devops-3ne9

How to Build and Deploy C# Azure Functions using Multi-Stage Pipelines in Azure DevOps

Introduction Emulators are cool pieces of technology that allow users to run a totally different system on top of another one. Here, we'll explore how a CPU works and how its software can emulate one by implementing a simple machine that will run programs written for a fantasy CPU. Emulators have a wide range of applications, like running x86 programs on ARM devices or running ARM Android applications on x86 Windows Desktops and even running your favorite retro game on an emulated computer/console on a Raspberry Pi. When a full system is emulated, the emulator software needs to handle all the hardware devices of those systems. This may include not only the CPU but also the video system, input devices, etc. However, the core concept of an emulator is nevertheless emulation of the CPU. Programs are just a series of bytes It's well known that CPUs are the core of a machine. Their main job is to execute programs. And programs are nothing more than a series of instructions in the computer's memory. At this point, you may be tempted to believe that your CPU knows JavaScript. Although a tempting concept, this is not the case. Imagine changing a CPU if a new version of JavaScript appeared! In reality, a CPU understands only a finite set of instructions; the instructions the CPU engineering team designed the CPU to understand. Users can create programs by using these instructions directly or by coding in a higher-level language and then using a compiler/system to translate the program into the set of instructions understood by the CPU. Regardless of how the user created the program, the instructions end up in memory as a series of bytes like these: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , 11 0 10 42 6 255 30 0 11 0 0 11 1 1 11 3 1 60 1 10 2 0 20 2 1 60 2 10 0 1 10 1 2 11 2 1 20 3 2 31 2 30 2 41 3 2 19 31 0 50 The CPU role is to fetch these instructions from memory and to execute them. Using mnemonics makes the task of writing programs much easier for humans. If one writes programs using the instructions mnemonics it is said that he codes in assembly language. It only takes a simple step to transform these programs written in assembly language into binary instructions (e.g. machine language). Instructions and mnemonics for our fantasy CPU, as described below, are quite intuitive. But we need to know the CPU instructions if we want to emulate that CPU into software. : Under each instruction is specified the number used to encode that particular instruction. Also registers , , , are encoded as numbers 0, 1, 2, 3): Note R0 R1 R2 R3 Loads the value from regsrc into regdst. E.g. regdst = regsrc reg_dst, reg_src = MOVR MOVR 10 Loads the numeric value into register regdst. E.g. regdst = value reg_dst, value = MOVV MOVV 11 Adds the value from regsrc to the value of regdst and store the result in reg_dst ADD reg_dst, reg_src ADD = 20 Subtracts the value of regsrc from the value of regdst and store the result in reg_dst reg_dst, reg_src = SUB SUB 21 Pushes the value of reg_src on the stack reg_src = PUSH PUSH 30 Pops the last value from stack and loads it into register reg_dst reg_dst = POP POP 31 Jumps the execution to address addr. Similar to a GOTO! = JP addr JP 40 Jump to the address addr only if the value from reg1 < reg2 (IF reg1 < reg2 THEN JP addr) reg_1, reg_2, = JL addr JL 41 Pushes onto the stack the address of instruction that follows CALL and then jumps to address addr addr = CALL CALL 42 Pops from the stack the last number, assumes is an address and jump to that address = RET RET 50 Print on the screen the value contained in the register reg reg = 60 PRINT PRINT Stops our VM. The virtual CPU doesn't execute instructions once HALT is encountered. = HALT HALT 255 Emulating the CPU Armed with the fantasy CPU specs, we can now move ahead to emulate the CPU in software – in JavaScript. As presented above, on real machines programs are stored in memory. In our emulator, we will emulate the memory using a simple array structure. As a matter of fact, we’ll only place a single program in the memory. program = [ , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ]; let 11 0 10 42 6 255 30 0 11 0 0 11 1 1 11 3 1 60 1 10 2 0 20 2 1 60 2 10 0 1 10 1 2 11 2 1 20 3 2 31 2 30 2 41 3 2 19 31 0 50 Our virtual CPU will need to fetch instructions one by one from this array and execute them. The CPU will keep track of the instruction that needs to fetch by using a special-purpose register named “PC” (Program Counter). Fact: PC register is a real register on many physical CPU architectures. The core of the CPU emulator is just a big “switch” statement that will process each instruction according to the specs. pc = ; halted = ; { (!halted)
    {
        runone();
    }
} { (halted) ; instr = program[pc]; (instr)
    { }
} let 0 let false ( ) function run while ( ) function runone if return let switch // handle each instruction according to specs // also advance pc to prepare for the next fetch // ... That’s all! This is the structure of our glorious CPU emulator. Processing instructions is also a very simple task. It requires only careful reading and implementation of the instruction’s specs. (instr)
{ :
        pc++; rdst = program[pc++]; rsrc = program[pc++];
        regs[rdst] = regs[rsrc]; ; :
        pc++; rdst = program[pc++]; val = program[pc++];
        regs[rdst] = val; ;

    ...

} switch // movr rdst, rsrc case 10 var var break // movv rdst, val case 11 var var break Take your time, read the specifications, and try to see if you can complete this virtual CPU implementation. You’ll know that you did a great job when you’ll see the results of the execution program. If you coded carefully, the program should display the first 10 Fibonacci numbers. You can also consult our version from this playground: https://codeguppy.com/code.html?simple_vm/vm0_fibonacci Loading the program As you saw in the above playground, our emulator implementation exists in a simple virtual machine that loads initially the program from an array of bytes and then asks the fantasy CPU to execute it. vm.load([ , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ]); 11 0 10 42 6 255 30 0 11 0 0 11 1 1 11 3 1 60 1 10 2 0 20 2 1 60 2 10 0 1 10 1 2 11 2 1 20 3 2 31 2 30 2 41 3 2 19 31 0 50 Loading like this is fine if your only intent is to load the program we’ve provided. But if you want to design your own programs in machine language and execute them, this may not be a very intuitive or efficient way. Here's a small technique that can be used to load the programs using a human-friendly CPU instruction mnemonics. It only takes defining a few constants: MOVR = ; MOVV = ; ADD  = ; SUB  = ; PUSH = ; POP  = ; JP   = ; JL   = ; CALL = ; RET  = ; PRINT= ; HALT = ; R0 = ; R1 = ; R2 = ; R3 = ;

vm.load([
    MOVV, R0, ,
    CALL, ,    
    HALT, PUSH, R0,
    
    MOVV, R0, ,
    MOVV, R1, ,
    MOVV, R3, ,
    PRINT, R1, MOVR, R2, R0,
    ADD, R2, R1,
    PRINT, R2,
    
    MOVR, R0, R1,
    MOVR, R1, R2,
    
    MOVV, R2, ,
    ADD, R3, R2,
    
    POP, R2,
    PUSH, R2,
    
    JL, R3, R2, ,
    
    POP, R0,
    
    RET
]); const 10 const 11 const 20 const 21 const 30 const 31 const 40 const 41 const 42 const 50 const 60 const 255 const 0 const 1 const 2 const 3 10 6 // PrintFibo: (addr = 6) 0 1 1 // continue: (addr = 19) 1 19 With this trick, it's like you’re programming in assembly language inside JavaScript. You can find the new program with mnemonics in this playground: https://codeguppy.com/code.html?simple_vm/vm1_fibonacci Now, we'll take the opportunity to quickly cover a few tools commonly used when working with machine language code. Assembler Perhaps the most important tool when working with machine language programs is an assembler program. This program lets users write programs as text files, in easier to use assembly language. Then, the assembler does the heavy lifting by converting the assembly source code into binary data understood by the CPU. We will attempt to build a simplified assembler program that does the basic job. It will work like this: code = ; bytes = asm.assemble(code); let `
// Loads value 10 in R0 
// and calls Fibonacci routine

MOVV R0, 10
CALL 6
HALT
...
` let If you want to see the code, please check this playground: https://codeguppy.com/code.html?simple_vm/vm3_assembler Disassembler Another useful tool that for working with machine language is a disassembler. A disassembler takes binary format and outputs its listing in a human-readable way, i.e. in assembly language. When run on the following program... src = asm.disassemble(
    [ , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ]
); let 11 0 10 42 6 255 30 0 11 0 0 11 1 1 11 3 1 60 1 10 2 0 20 2 1 60 2 10 0 1 10 1 2 11 2 1 20 3 2 31 2 30 2 41 3 2 19 31 0 50 … our disassembler should output this: MOVV R0, CALL HALT PUSH R0 MOVV R0, MOVV R1, MOVV R3, PRINT R1 MOVR R2, R0 ADD R2, R1 PRINT R2 MOVR R0, R1 MOVR R1, R2 MOVV R2, ADD R3, R2 POP R2 PUSH R2 JL R3, R2, POP R0 RET 0 11 0 10 10 3 42 6 6 5 255 6 30 0 8 11 0 0 0 11 11 1 1 1 14 11 3 1 1 17 60 6 19 10 2 0 22 20 2 1 25 60 6 27 10 0 1 30 10 1 2 33 11 2 1 1 36 20 3 2 39 31 2 2 41 30 2 43 41 3 2 19 19 47 31 0 2 49 50 The listing contains the memory addresses and binary instructions and associated mnemonic for each instruction in our program. To see a very simplistic implementation of a disassembler, please check this playground: https://codeguppy.com/code.html?simple_vm/vm2_disassembler About Fibonacci program You're probably wondering how we came up with the assembly program to print the Fibonacci numbers? We first wrote first the algorithm in JavaScript and then convert it step by step to assembler: Once experienced with writing in assembly, this task can be done in one step. It just requires practice! Conclusion Even if there is still a lot of work before emulating a full system, hopefully this provided a basic overview of what it takes to emulate the core of a system – the CPU. All the programs in this article and explanations are included in the following playground: https://codeguppy.com/code.html?simple_vm/vm As a next step, I invite you to create additional programs for this fantasy CPU and if needed extend the CPU instruction set with new instructions to support your programs. Looking forward to your feedback and comments. Please let me know if you want to see more about this subject, perhaps even seeing the implementation of a full emulator. For more recreational coding programs please feel free to browse codeguppy.com

How to Build an Emulator for a Fantasy CPU in JavaScript

The AWS CDK is a software development framework to define cloud infrastructure as code and provision it through CloudFormation. The CDK integrates fully with AWS services and allows developers to use high-level construct to define cloud infrastructure in code. In this article, we will build a CDK version of AWS EC2 Instance Scheduler solution that enables us to easily configure custom start and stop schedules for our Amazon EC2 and Amazon RDS instances. The Architecture At the end of this article, we have a pipeline to deploy a serverless solution that start and stop Amazon EC2 instances in an autoscalling group and Amazon RDS instances based on a schedule. Here’s the architecture diagram: Through the article we will be creating the following resources: Deploy an AWS Step Function with two parallel tasks. Create an SNS topic to send notifications. Create a Cloudeatch event rule which will trigger Step Function based on a schedule. Create a CI/CD pipeline with CodeBuild and CodePipeline. Prerequisites To deploy the CDK application, there are a few prerequisites that need to be met: Setup an AWS account. Install the latest aws-cli. Install AWS . CDK CLI Deploy a (optional). multi-AZ wordpress website with RDS Before you begin First, create an AWS CDK project by entering the following commands at the command line. $ mkdir cdk-sample $ cdk-sample cdk init --language=javascript cd Next, install CDK modules, we will use below modules in our project. $npm install -cdk/core -cdk/aws-codebuild -cdk/aws-codepipeline -cdk/aws-codepipeline-actions -cdk/aws-events -cdk/aws-events-targets -cdk/aws-iam -cdk/aws-lambda -cdk/aws-sns -cdk/aws-ssm -cdk/aws-stepfunctions -cdk/aws-stepfunctions-tasks @aws @aws @aws @aws @aws @aws @aws @aws @aws @aws @aws @aws We need to add a stage parameter because we want to deploy our stack to multiple stages (dev and production). Let’s add in . DEP_ENV bin/cdk-sample.js cdk = ( ); BaseStackConstruct = ( ); deployEnv = process.env.DEPLOY_ENV || ; app = cdk.App(); BaseStackConstruct(app, , { : { : }, : deployEnv,
}); #!/usr/bin/env node const require '@aws-cdk/core' const require '../lib/base-stack' const 'dev' const new new `CDKSample` env region 'ap-southeast-2' stage Define the base stack class Now let’s define our base stack class. In the base stack class,  we’ll add the code to instantiate three separate stacks: SNS stack, StepFunction stack and CodePipeline stack. Make the code look like the following. { Construct } = ( ); SNSAlertStac = ( ); StepfunctionStack = ( ); CodePipelineStack = ( ); lambda = ( ); .exports = { (scope, id, props) { (scope, id, props); sNSAlertStac = SNSAlertStac(scope, ); (!process.env.MANUAL_DEPLOY) { cfnParametersCode = lambda.Code.fromCfnParameters(); StepfunctionStack(scope, , { : sNSAlertStac.topic, : cfnParametersCode,
      }); CodePipelineStack(scope, , { : cfnParametersCode, : props.stage,
      });
    } { StepfunctionStack(scope, , { : sNSAlertStac.topic,
      });
    }
  }
}; const require '@aws-cdk/core' const require './sns-stack' const require './lambda-stack' const require './codepipeline-stack' const require '@aws-cdk/aws-lambda' module class BaseStackConstruct extends Construct constructor super //  stack for SNS const new `SNSAlert- ` ${props.stage} // Deploy step functions from codepipeline if const new `Stepfunction- ` ${props.stage} snsTopic lambdaCode new `CodepipelienStack- ` ${props.stage} lambdaCode stage else //deploy step function from local env new `Stepfunction- ` ${props.stage} snsTopic We can set optional environment variable to true if we want to deploy only step function locally. MANUAL_DEPLOY $ MANUAL_DEPLOY= && cdk deploy Stepfunction-dev export true Define SNS stack We’ll add the code (lib/sns-stack.js) to create an SNS topic and subscribe an email to the created topic. { Stack } = ( ); sns = ( ); subs = ( ); EMAIL_SUBSCRIPTION = ; .exports = { (scope, id, props) { (scope, id, props); .topic = sns.Topic( , , { : ,
    }); .topic.addSubscription( subs.EmailSubscription(EMAIL_SUBSCRIPTION));
  }
}; const require '@aws-cdk/core' const require '@aws-cdk/aws-sns' const require '@aws-cdk/aws-sns-subscriptions' const 'test@test.com' module class SNSAlertStac extends Stack constructor super this new this 'AlertTopic' displayName 'Step function execution failed' this new Define Step function and Lambdas Now we’ll expand our file and add Lambda functions and Step function. lib/lambda-stack.js In this example we will create two lambda functions, to update auto scaling group, and to start/stop RDS instances. updateScalingGroupFn updateDBClusterFn { Stack, ScopedAws, Duration } = ( ); { , Runtime, Code } = ( ); { PolicyStatement } = ( ); { SfnStateMachine } = ( ); { Rule, Schedule } = ( ); ssm = ( ); sfn = ( ); tasks = ( ); { join } = ( ); .exports = { (scope, id, props) { (scope, id, props); autoScalingGroupName = ssm.StringParameter.valueForStringParameter( , ); dBInstanceName = ssm.StringParameter.valueForStringParameter( , ); { accountId, region } = ScopedAws( ); updateScalingGroupFn = ( , , { : Runtime.NODEJS_12_X, : , : props.lambdaCode || Code.fromAsset(join(__dirname, )), : {
        autoScalingGroupName,
      },
    }); updateDBClusterFn = ( , , { : Runtime.NODEJS_12_X, : , : props.lambdaCode || Code.fromAsset(join(__dirname, )), : {
        dBInstanceName,
      },
    }); statementUpdateASLGroup = PolicyStatement();
    statementUpdateASLGroup.addActions( );
    statementUpdateASLGroup.addResources( );
    updateScalingGroupFn.addToRolePolicy(statementUpdateASLGroup); statementDescribeASLGroup = PolicyStatement();
    statementDescribeASLGroup.addActions( );
    statementDescribeASLGroup.addResources( );
    updateScalingGroupFn.addToRolePolicy(statementDescribeASLGroup); statementDescribeDBCluster = PolicyStatement();
    statementDescribeDBCluster.addActions( );
    statementDescribeDBCluster.addResources( );
    updateDBClusterFn.addToRolePolicy(statementDescribeDBCluster); statementToggleDBCluster = PolicyStatement();
    statementToggleDBCluster.addActions([ , ,
    ]);
    statementToggleDBCluster.addResources( );
    updateDBClusterFn.addToRolePolicy(statementToggleDBCluster);
  }
}; const require '@aws-cdk/core' const Function require '@aws-cdk/aws-lambda' const require '@aws-cdk/aws-iam' const require '@aws-cdk/aws-events-targets' const require '@aws-cdk/aws-events' const require '@aws-cdk/aws-ssm' const require '@aws-cdk/aws-stepfunctions' const require '@aws-cdk/aws-stepfunctions-tasks' const require 'path' module class StepfunctionStack extends Stack constructor super // retriving autoscaling group name and rds db cluster name from SSM const this '/cdksample/autoscalling/name' const this '/cdksample/dbcluster/name' const new this //creating lambda functions const new Function this 'updateScalingGroupFn' runtime handler 'lambda_update_asg/index.handler' code '../src' environment const new Function this 'updateDBCluster' runtime handler 'lambda_update_db_cluster/index.handler' code '../src' environment //IAM policies for updateScalingGroupFn lambda const new 'autoscaling:UpdateAutoScalingGroup' `arn:aws:autoscaling: : :autoScalingGroup:*:autoScalingGroupName/ ` ${region} ${accountId} ${autoScalingGroupName} const new 'autoscaling:DescribeAutoScalingGroups' '*' //IAM policies for updateDBCluster lambda const new 'rds:DescribeDBInstances' '*' const new 'rds:StartDBInstance' 'rds:StopDBInstance' '*' Next, we will continue by adding our step function definitions. Add the following code to . lib/lambda-stack.js updateScalingGroupTask = tasks.LambdaInvoke( , ,
      { : updateScalingGroupFn,
      }
    ); updateDBClusterTask = tasks.LambdaInvoke( , ,
      { : updateDBClusterFn,
      }
    ); sendFailureNotification = tasks.SnsPublish( , ,
      { : props.snsTopic, : sfn.TaskInput.fromDataAt( ),
      }
    ); stepChain = sfn.Parallel( , )
      .branch(updateScalingGroupTask)
      .branch(updateDBClusterTask)
      .addCatch(sendFailureNotification); toggleAWSServices = sfn.StateMachine( , , { : stepChain, : Duration.minutes( ),
    }); const new this 'Update asg task' lambdaFunction const new this 'StopStart db cluster task' lambdaFunction const new this 'Publish alert notification' topic message '$.error' const new this 'Stop and Start EC2 Instances and RDS in parallel' const new this 'StateMachine' definition timeout 5 As we can see, for each Lambda there is a corresponding taskEvent. We only want to parallelize the Lamba workload (one task for the ec2 autoscaling group and another task for RDS instances). Hence we will add a chain to our workflow by calling the function. branch() To send a notification to Amazon SNS topic if the Lambda fails, we can add an error handling chain to the workflow by calling function. addCatch() Finally, let’s define a CloudWatch Events rule, CloudWatch is triggering execution of state machine workflow every day 7am and 6pm (UTC). Add the following code to . lib/lambda-stack.js Rule( , , { : Schedule.expression( ), : [ SfnStateMachine(toggleAWSServices)],
}); new this 'Rule' schedule 'cron(0 7,18 * * ? *)' targets new Define pipeline stack We define our final stack, codepiepeline-stack. It has a source Action targeting the Github repository, a build Action that builds previously defined stacks, and finally a deploy Action that uses AWS CloudFormation. It takes the Cloudformation template (cdk.out/*.template.json) generated by the AWS CDK build action and passes it to AWS CloudFormation for deployment. Create lib/codepipeline-stack.js and put the following code in it. cdk = ( ); codebuild = ( ); codepipeline = ( ); codepipeline_actions = ( ); ssm = ( ); packageJson = ( ); { (scope, id, props) { (scope, id, props); sourceOutput = codepipeline.Artifact(); cdkBuildOutput = codepipeline.Artifact( ); lambdaBuildOutput = codepipeline.Artifact( ); branch = props.stage === ? : ; codepipeline.Pipeline( , , { : , : [
        { : , : [ codepipeline_actions.GitHubSourceAction({ : , : sourceOutput, : ssm.StringParameter.valueForStringParameter( , ), : ,
              branch, : ,
            }),
          ],
        },
        { : , : [ codepipeline_actions.CodeBuildAction({ : , : codebuild.PipelineProject( , , { : codebuild.BuildSpec.fromObject({ : + , : { : { : ,
                    }, : { : ,
                    }, : { : [ , ],
                    },
                  }, artifacts: { : { : { : , : [ ],
                      }, : { : , : [ ],
                      },
                    },
                  },
                }),
              }), : sourceOutput, : [cdkBuildOutput, lambdaBuildOutput],
            }),
          ],
        },
        { : , : [ codepipeline_actions.CloudFormationCreateUpdateStackAction({ : , : cdkBuildOutput.atPath( ), : , : ,
            }), codepipeline_actions.CloudFormationCreateUpdateStackAction({ : , : cdkBuildOutput.atPath( ), : , : , : {
                ...props.lambdaCode.assign(lambdaBuildOutput.s3Location),
              }, : [lambdaBuildOutput], : ,
            }),
          ],
        },
      ],
    });
  }
} .exports = CodePipelineStack; const require '@aws-cdk/core' const require '@aws-cdk/aws-codebuild' const require '@aws-cdk/aws-codepipeline' const require '@aws-cdk/aws-codepipeline-actions' const require '@aws-cdk/aws-ssm' const require '../package.json' . class CodePipelineStack extends cdk Stack constructor super const new const new 'CdkBuildOutput' const new 'LambdaBuildOutput' const 'dev' 'dev' 'master' new this 'Pipeline' pipelineName `DeployScheduleService- ` ${props.stage} stages stageName 'Source' actions new actionName 'Code' output oauthToken this '/github/token' owner 'yai333' repo 'cdkexample' stageName 'Build' actions new actionName 'Build_CDK_LAMBDA' project new this 'Build' buildSpec version ` . ` ${
                    packageJson.version.split( )[ ]
                  } '.' 0 ${+packageJson.version.split( ).slice( ).join( )} '.' -2 '' phases install commands 'npm install' build commands `export DEPLOY_ENV= && npm run cdk synth` ${props.stage} post_build commands 'cd src && npm install' 'ls src -la' // save the generated files in the correct artifacts 'secondary-artifacts' CdkBuildOutput 'base-directory' 'cdk.out' files '**/*' LambdaBuildOutput 'base-directory' 'src' files '**/*' input outputs stageName 'Deploy' actions new actionName 'Deploy_SNS_Stack' templatePath `SNSAlert- .template.json` ${props.stage} stackName `SNSStack- ` ${props.stage} adminPermissions true new actionName 'Deploy_Lambda_Stack' templatePath `Stepfunction- .template.json` ${props.stage} stackName `StepfunctionStack- ` ${props.stage} adminPermissions true parameterOverrides extraInputs runOrder 2 module Next, create dev branch and check the code into Git then push it to Github repo. $ git branch dev $ git checkout dev $ git add . $ git commit -m "xxxx" $ git push Deploying the pipeline Now we can deploy the pipeline with multiple Stages. Deploy pipeline to dev stage, source action targets the Github repository dev branch. =dev && cdk deploy CodepipelienStack-dev $export DEPLOY_ENV Deploy pipeline to the production stage, source action targets the Github repository master branch. $ DEPLOY_ENV=production && cdk deploy CodepipelienStack-production export After the deployment finishes, we should have a three-stage pipeline that looks like the following. Once all stacks have deployed, we can explore it in the AWS Console and give it a try. Navigate to the Step Function in the console and click “Start execution”. We should see it passes. Let’s check EC2 autoscaling group’s DesiredCapacity and RDS instance’s status. rds - -instances : [
{ : , : , : , : ... $aws describe db "DBInstances" "DBInstanceIdentifier" "cxxxxxx" "DBInstanceClass" "db.t2.small" "Engine" "mysql" "DBInstanceStatus" "stopped" rds - -instances : [
{ : , : 0, : 0, : 0,
... $aws describe db "AutoScalingGroups" "AutoScalingGroupName" "cdk-sample-WebServerGroup-xxxxxx" "MinSize" "MaxSize" "DesiredCapacity" Finally, let’s check the cloudwatch event rule. We should see the cloudwatch event rule looks like the following. $ { : [
{ : , : , : , : , : }
  ]
} aws events list-rules "Rules" "Name" "StepfunctionStack-dev-Rulexxxxxxx" "Arn" "arn:aws:events:ap-southeast-2:xxxxxxx:rule/StepfunctionStack-dev-Rulexxxxxxx-xxxxxxx" "State" "ENABLED" "ScheduleExpression" "cron(0 7,18 * * ? *)" "EventBusName" "default" That’s about it, Thanks for reading! I hope you have found this article useful, You can find the complete project in my . GitHub repo

Stories, News & Mentions about RUNO

Runo’s Stories on HackerNoon