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

Incuto

incuto

Out of Office: why month-long holidays are the key to Swedish unicorn ...

Future of Cities Debate: building world class urban innovation centres for the future

ClearBank Ltd., an enabler of bank accounts, real-time clearing, and embedded banking for financial institutions, presents its unaudited H1 2023 results. The bank saw “a 144% YoY increase in ...

Tagged: clearbank

Once, I had a requirement to implement server-side logging for GRPC requests. GRPC has an interceptor mechanism that can be used for logging, GRPC request verification, authentication, etc. To intercept requests on the server side, it is necessary to implement ServerInterceptor. And inherit two abstract classes, ServerCall and ServerCall.Listener. First, let’s make our implementation of ServerCall.Listener. There is ForwardingServerCallListener that gives calls to the next listener in the chain. We will extend this class and override the method onMessage. We will use the ConcurrentLinkedQueue for storing received requests. This method might be invoked more than one time if using client-side streaming. Also, there are the onComplete and onCancel methods that will be invoked after completing the GRPC request or after the client’s cancelation. Our implementation uses the queue for storing sent requests. class LoggingServerCallListener<ReqT>(
    private val delegate: ServerCall.Listener<ReqT>,
    private val input: ConcurrentLinkedQueue<ReqT>
) : ForwardingServerCallListener<ReqT>() {

    override fun delegate(): ServerCall.Listener<ReqT> {
        return delegate
    }

    override fun onMessage(message: ReqT) {
        super.onMessage(message)
        input.offer(message)
    }
} Next, we need to implement the ServerCall class. There is the implementation SimpleForwardingServerCall that works as ForwardingServerCallListener for ServerCall.Listener. We will use the same instance of ConcurrentLinkedQueue for getting received requests. Also, we will use another instance of the queue for storing sent responses. We will implement the sendMessage method that invokes before a response is sent to a client. This method can be invoked more than once if the result is server-side streaming. We will also override the close method, which will be called after all data has been sent to the client or an error occurs. The method ensures that there will be no further calls to onMessage or sendMessage. import com.google.protobuf.GeneratedMessageV3
import com.google.protobuf.util.JsonFormat
import io.grpc.ForwardingServerCall.SimpleForwardingServerCall
import io.grpc.Metadata
import io.grpc.ServerCall
import io.grpc.Status
import org.slf4j.LoggerFactory
import java.util.concurrent.ConcurrentLinkedQueue

class LoggingServerCall<RequestType, ResponseType>(
    delegate: ServerCall<RequestType, ResponseType>,
    private val metadata: Metadata,
    private val input: ConcurrentLinkedQueue<RequestType>,
    private val output: ConcurrentLinkedQueue<ResponseType>
) : SimpleForwardingServerCall<RequestType, ResponseType>(delegate) {

    override fun sendMessage(message: ResponseType) {
        output.offer(message)
        super.sendMessage(message)
    }

    override fun close(status: Status, trailers: Metadata) {
        if (status.isOk) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)

            val printer = JsonFormat.printer()

            val request = input
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            val response = output
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            logger.info("The request with id: $requestId and request data $request returns $response")

        } else if (listOf(Status.INTERNAL.code, Status.NOT_FOUND.code, Status.INVALID_ARGUMENT.code).contains(status.code)) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)
            logger.error("An error occurred while processing the request with request-id $requestId", status.asRuntimeException())
        }

        super.close(status, trailers)
    }

    companion object {
        private val logger = LoggerFactory.getLogger(LoggingServerCall::class.java)
        private val REQUEST_ID_METADATA_KEY = Metadata.Key.of("x-request-id", Metadata.ASCII_STRING_MARSHALLER)
    }
} Our implementation is very simple. We use JsonFormater for converting protobuf to JSON and joining to the string. Also, we take a request ID from the metadata for emulating real logging situations. Then we log the message into the system out. If an error occurs, we will log it. After that, the onComplete/onCancel methods of the listener will be called. Next, we must implement our ServerInterceptor which uses both our ServerCall and ServerCall.Listener. class LoggingInterceptor : ServerInterceptor {
    override fun <ReqT : Any, RespT : Any?> interceptCall(
        call: ServerCall<ReqT, RespT>,
        headers: Metadata,
        next: ServerCallHandler<ReqT, RespT>
    ): ServerCall.Listener<ReqT> {
        val input = ConcurrentLinkedQueue<ReqT>()
        val output = ConcurrentLinkedQueue<RespT>()
        val loggingServerCall = LoggingServerCall(call, headers, input, output)
        return LoggingServerCallListener(next.startCall(loggingServerCall, headers), input)
    }
} To start the processing request, we must call the startCall method of the ServerCallHandler class. After that, we must register our server interceptor. fun main(args: Array<String>) {
	val server = ServerBuilder
        .forPort(8080)
		.addService(OurGrpcService())
		.intercept(LoggingInterceptor())
		.build()
	
	server.start()
} In the second part, we consider how to work with client interceptors. I hope the article can help you with how to work with the server-side interceptors in GRPC.

How to Implement Server-Side Interceptors for Logging GRPC Requests

Real Time Data Processing: Easily Processing 10 Million Messages With Golang, Kafka and MongoDB

How to Use Next.js to Implement the Backends-for-Frontends Pattern

The world of NFTs is vast and although this type of asset has been in circulation for several years now, the news and developments related to them have not stopped, bringing novelty and innovation in the creation and in providing additional previously unthinkable features. Apparently, this trend that has launched the various blockchains to be more used, thanks to the simplicity of creating NFTs, has led to some blockchains achieving greater success than others, with some remaining behind, such as that of Bitcoin, which, due to its structure and characteristics focused more on security than on speed or cost, is not configured as an optimal blockchain for NFT minting. Despite this, it doesn't mean that we cannot create NFTs on this blockchain, however by paying high fees and obviously also clogging up the related blockchain, creating heavy blocks containing information other than those for which the blockchain was designed. We will go into detail about how to create NFTs on Bitcoin and what the process is for creating both a compatible wallet and the NFTs themselves. NFT with the Ordinals protocol Some of you may know that 1 bitcoin is made up of 100 million units, called satoshis or sat for short, and these satoshis are numbered in order starting from 0. In fact, these numbers are “ordinal numbers”, and because of this, it is possible to exploit them to create NFTs. For those who want to learn more about this protocol, we recommend , instead below there is the algorithm that was created: checking here # subsidy of block at given height
def subsidy(height):
return 50 * 100_000_000 >> height // 210_000
# first ordinal of subsidy of block at given height
def first_ordinal(height):
start = 0
for height in range(height):
start += subsidy(height)
return start
# assign ordinals in given block
def assign_ordinals(block):
first = first_ordinal(block.height)
last = first + subsidy(block.height)
coinbase_ordinals = list(range(first, last))
for transaction in block.transactions[1:]:
ordinals = []
for input in transaction.inputs:
ordinals.extend(input.ordinals)
for output in transaction.outputs:
output.ordinals = ordinals[:output.value]
of ordinals[:output.value]
coinbase_ordinals.extend(ordinals)
for output in block.transaction[0].outputs:
output.ordinals = coinbase_ordinals[:output.value]
from coinbase_ordinals[:output.value] How to create a Bitcoin address for NFTs These NFTs exploit the satoshis and since the satoshis themselves are fungible, if we don't take precautions, we could end up transferring in a transaction even those satoshis to which the NFTs we have created are connected. We need to create a new address and wallet that allows us to have greater control over the movements of the satoshis in our address, and a useful tool for this purpose is certainly . Sparrow Wallet The first step is to download Sparrow wallet and create a new bitcoin address. After installing the wallet, we will have to create a new wallet and to do this we go to File and New Wallet: In the next screen, we will have to set a new address and to do it in the "Address" section we must choose "Taproot (P2TR)": Then we will need to click on the "New or Imported Bitcoin Address" button below to create a new Bitcoin address with those characteristics: At this point we should create the words relating to our address and we opt to use the number of words we prefer, in our case 12 words and press the "Generate New" button: Let's remember to type these words into the next step we will have to insert them and then press the "Create Keystore" button: Now we can import the keystore we created earlier, by clicking on the Import button: Finally, after we have created everything, we will have to press the "Apply" button: How to receive Bitcoin NFTs Using this wallet, we can also receive NFTs and we must remember to always create a new account to receive the different NFTs, and to do so, in the "Receive" menu, we find the button below to create a new address "Get Next Address" and use the address shown to us: To receive Bitcoin NFTs, we should freeze the UTXOs related to the NFTs and do so, we should right-click on the related transaction, then click the "Freeze UTXO" item. This will ensure that we will not send these NFTs by mistake. When we should transfer them, just do the reverse process and click on "Unfreze UTXO". How to mint an NFT on Bitcoin Now that we have all the tools to receive and avoid losing NFTs by mistake, it's time to see how to create our NFTs and do this we have two solutions, either by taking advantage of the related algorithm created and therefore all at the command line, or take advantage of some convenient and practical services. For those more geeks, they can check out the code directly on GitHub , instead for those who want the simplest approach we can take advantage of or , also because the procedure is simple and the steps are similar. here this service this other The first thing you need to do is load the image we want to transform into an NFT: After that, we have to enter our address where our NFT will be sent: At this point, we just have to pay the lee fee and wait for the transaction to arrive at our address, and in this case, we see that we are going to spend just under $13 and wait over 24 hours, while if we want the transaction to be processed in 30 minutes, then we should pay more around $70: How to see Bitcoin NFTs Once we have created the NFT, we can see it through some platforms , and just enter the hash of the transaction relating to the NFT to see all the information relating to it: like this Conclusions Bitcoin-based tokens are possible even if they are a little complicated and require a higher investment than on other platforms. Additionally, the cost of creating them is not as cheap as on other platforms. Finally I conclude with a video of the process: https://youtu.be/4losgVDBxIE?embedable=true

Creating NFTs on the Bitcoin Network

Doubtful Points and Criticism

Difficulties and Preliminary Approach

When I decided to build an open-source earlier this year and to build it in C# I needed a template for building the transport layer of the server. I was particularly happy when I checked out the TechEmpower benchmarks in which ASP.NET Kestrel currently ranks 3rd in plaintext benchmark scores with 7,023,107 responses per second. In this post, I will demonstrate how a high-performance TCP server can be built and I will do so by borrowing some ideas from Kestrel. Telegram Server The code presented leverages low allocation asynchronous programming patterns and pooling to be blazing fast. Socket operations in .NET are described by which is a reusable object that provides a callback-based asynchronous pattern. First this pattern needs to be wrapped with an async one by implementing the interface so that allocations for the asynchronous path can be avoided. SocketAsyncEventArgs IValueTaskSource AwaitableEventArgs.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketAwaitableEventArgs.cs#L10-L77
public class AwaitableEventArgs : SocketAsyncEventArgs, IValueTaskSource<int>
{
    private ManualResetValueTaskSourceCore<int> _source;

    public AwaitableEventArgs() :
        base(unsafeSuppressExecutionContextFlow: true)
    {
    }

    protected override void OnCompleted(SocketAsyncEventArgs args)
    {
        if (SocketError != SocketError.Success)
        {
            _source.SetException(new SocketException((int)SocketError));
        }

        _source.SetResult(BytesTransferred);
    }

    public int GetResult(short token)
    {
        int result = _source.GetResult(token);
        _source.Reset();
        return result;
    }

    public ValueTaskSourceStatus GetStatus(short token)
    {
        return _source.GetStatus(token);
    }

    public void OnCompleted(Action<object?> continuation, object? state, short token,
        ValueTaskSourceOnCompletedFlags flags)
    {
        _source.OnCompleted(continuation, state, token, flags);
    }
} This is rewritten from the original implementation and the main difference is this version uses for the sake of simplicity while the original one uses a thinner custom implementation of the interface. here ManualResetValueTaskSourceCore IValueTaskSource Needed and implementations are derived from the above. They first set the buffer for the and then call the respective or method of the which returns true if the I/O operation is pending in which case can be the for the returned as the base class implements the interface. When is fired, awaited will either return the bytes received/sent or throw an . However if the above call returns false it means the I/O operation completed synchronously and synchronous path needs to be handled. Receiver Sender AwaitableEventArgs SocketAsyncEventArgs SendAsync ReceiveAsync Socket Receiver/Sender source ValueTask OnCompleted(SocketAsyncEventArgs args) ValueTask Exception Receiver.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketReceiver.cs
public class Receiver : AwaitableEventArgs
{
   private short _token;
   public ValueTask<int> ReceiveAsync(Socket socket, Memory<byte> memory)
   {
      SetBuffer(memory);
      if (socket.ReceiveAsync(this))
      {
         return new ValueTask<int>(this, _token++);
      }

      var transferred = BytesTransferred;
      var err = SocketError;
      return err == SocketError.Success
         ? new ValueTask<int>(transferred)
         : ValueTask.FromException<int>(new SocketException((int)err));
   }
} also needs to handle the buffer being a as it will be the case. Sender ReadOnlySequence<byte> Sender.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketSender.cs
public class Sender: AwaitableEventArgs
{
    private short _token;
    private List<ArraySegment<byte>>? _buffers;
    public ValueTask<int> SendAsync(Socket socket, in ReadOnlyMemory<byte> data)
    {
        SetBuffer(MemoryMarshal.AsMemory(data));
        if (socket.SendAsync(this))
        {
            return new ValueTask<int>(this, _token++);
        }

        var transferred = BytesTransferred;
        var err = SocketError;
        return err == SocketError.Success
            ? new ValueTask<int>(transferred)
            : ValueTask.FromException<int>(new SocketException((int)err));
    }
    public ValueTask<int> SendAsync(Socket socket, in ReadOnlySequence<byte> data)
    {
        if (data.IsSingleSegment)
        {
            return SendAsync(socket, data.First);
        }
        _buffers ??= new List<ArraySegment<byte>>();
        foreach (var buff in data)
        {
            if (!MemoryMarshal.TryGetArray(buff, out var array))
            {
                throw new InvalidOperationException("Buffer is not backed by an array.");
            }

            _buffers.Add(array);
        }

        BufferList = _buffers;

        if (socket.SendAsync(this))
        {
            return new ValueTask<int>(this, _token++);
        }

        var transferred = BytesTransferred;
        var err = SocketError;
        return err == SocketError.Success
            ? new ValueTask<int>(transferred)
            : ValueTask.FromException<int>(new SocketException((int)err));
    }
    public void Reset()
    {
        if (BufferList != null)
        {
            BufferList = null;

            _buffers?.Clear();
        }
        else
        {
            SetBuffer(null, 0, 0);
        }
    }
} A lightweight implementation is also needed. This is backed by a and leverages for keeping a cheaper atomic count. SenderPool ConcurrentQueue Interlocked SenderPool.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketSenderPool.cs
public class SenderPool : IDisposable
{
    private readonly int MaxNumberOfSenders;
    private int _count;
    private readonly ConcurrentQueue<Sender> _senders = new();
    private bool _disposed = false;

    public SenderPool(int maxNumberOfSenders = 128)
    {
        MaxNumberOfSenders = maxNumberOfSenders;
    }

    public Sender Rent()
    {
        if (_senders.TryDequeue(out var sender))
        {
            Interlocked.Decrement(ref _count);
            sender.Reset();
            return sender;
        }

        return new Sender();
    }

    public void Return(Sender sender)
    {
        if (_disposed || _count >= MaxNumberOfSenders)
        {
            sender.Dispose();
        }
        else
        {
            Interlocked.Increment(ref _count);
            _senders.Enqueue(sender);
        }
    }

    public void Dispose()
    {
        if (_disposed) return;
        _disposed = true;
        while (_senders.TryDequeue(out var sender))
        {
            sender.Dispose();
        }
    }
} Now this is the part things start to get more fun. Writing a TCP server requires buffering and parsing streaming data which is a complex task and can be tedious and hard to get right the first time around. Luckily is designed exactly for this problem. It reduces code complexity and allows high performance parsing of streaming data. I highly recommend anyone reading this to read the original as well to get a better grasp. Next piece of code will leverage this library. System.IO.Pipelines article Connection.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketConnection.cs
public class Connection : IAsyncDisposable
{
    private const int MinBuffSize = 1024;
    private readonly Socket _socket;
    private readonly Receiver _receiver;
    private Sender? _sender;
    private readonly SenderPool _senderPool;
    private Task? _receiveTask;
    private Task? _sendTask;
    private readonly Pipe _transportPipe;
    private readonly Pipe _applicationPipe;
    private readonly object _shutdownLock = new object();
    private volatile bool _socketDisposed;
    public PipeWriter Output { get;}
    public PipeReader Input { get;}

    public Connection(Socket socket, SenderPool senderPool)
    {
        _socket = socket;
        _receiver = new Receiver();
        _senderPool = senderPool;
        _transportPipe = new Pipe();
        Output = _transportPipe.Writer;
        _applicationPipe = new Pipe();
        Input = _applicationPipe.Reader;
    }

    public void Start()
    {
        try
        {
            _sendTask = SendLoop();
            _receiveTask = ReceiveLoop();
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
    }
    private async Task SendLoop()
    {
        try
        {
            while (true)
            {
                var result = await _transportPipe.Reader.ReadAsync();
                if (result.IsCanceled)
                {
                    break;
                }
                var buff = result.Buffer;
                if (!buff.IsEmpty)
                {
                    _sender = _senderPool.Rent();
                    await _sender.SendAsync(_socket, result.Buffer);
                    _senderPool.Return(_sender);
                    _sender = null;
                }
                _transportPipe.Reader.AdvanceTo(buff.End);
                if (result.IsCompleted)
                {
                    break;
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
        finally
        {
            _applicationPipe.Writer.Complete();
            Shutdown();
        }
    }
    private async Task ReceiveLoop()
    {
        try
        {
            while (true)
            {
                var buff = _applicationPipe.Writer.GetMemory(MinBuffSize);
                var bytes = await _receiver.ReceiveAsync(_socket, buff);
                if (bytes == 0)
                {
                    break;
                }
                _applicationPipe.Writer.Advance(bytes);
                var result = await _applicationPipe.Writer.FlushAsync();
                if (result.IsCanceled || result.IsCompleted)
                {
                    break;
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
        finally
        {
            _applicationPipe.Writer.Complete();
            Shutdown();
        }
    }

    public async ValueTask DisposeAsync()
    {
        _transportPipe.Reader.Complete();
        _applicationPipe.Writer.Complete();
        try
        {
            if (_receiveTask != null)
            {
                await _receiveTask;
            }

            if (_sendTask != null)
            {
                await _sendTask;
            }
        }
        finally
        {
            _receiver.Dispose();
            _sender?.Dispose();
        }
    }
    public void Shutdown()
    {
        lock (_shutdownLock)
        {
            if (_socketDisposed)
            {
                return;
            }
            _socketDisposed = true;
            try
            {
                _socket.Shutdown(SocketShutdown.Both);
            }
            finally
            {
                _socket.Dispose();
            }
        }
    }
} The class has: Connection a for the connection Receiver references to the and the Socket SenderPool a for transport and another one for the application Pipe and finally two loops for sending and receiving. So how do we send/receive data? The for the transport pipe is exposed as the public property and the polls for data written to this pipe renting a before every send operation returning it to the pool after completion. The for the application pipe is exposed as the public property and the basically gets a buffer from this pipe and receives into it. Then there is some cleanup code. This again is a simplified version of the original Kestrel implementation. PipeWriter Output SendLoop Sender PipeReader Input ReceiveLoop TCP Echo At this point a TCP Echo server needs just a few more lines of code. Following simply copies back the received bytes: Program.cs var senderPool = new SenderPool(1024);
var listenSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 8989));
listenSocket.Listen(128);
while (true)
{
    var socket = await listenSocket.AcceptAsync();
    var connection = new Connection(socket, senderPool);
    _ = ProcessConnection(connection);
}

static async Task ProcessConnection(Connection connection)
{
    connection.Start();
    while (true)
    {
        var result = await connection.Input.ReadAsync();
        if (result.IsCanceled)
        {
            break;
        }
        var buff = result.Buffer;
        if (!buff.IsEmpty)
        {
            if (buff.IsSingleSegment)
            {
                await connection.Output.WriteAsync(buff.First);
            }
            else
            {
                foreach (var mem in buff)
                {
                    await connection.Output.WriteAsync(mem);
                }
            }
        }
        connection.Input.AdvanceTo(buff.End, buff.End);
        if (result.IsCompleted)
        {
            break;
        }
    }
    connection.Shutdown();
    await connection.DisposeAsync();
} This will serve as a base for a High Performance TCP Server but of course more measurements and optimizations might be necessary. Code above omits some more advanced implementation details for the sake of simplicity. Some of them are outlined below. schedule-me-not When creating a , it’s possible to specify a and ‘s for the reader and the writer via the and Kestrel uses a custom here along with a lock-free . implementation as well supports a as to have fine-grained control where the I/O happens. Following pseudo-code tries to simplify and outline how Kestrel utilizes schedulers. Pipe MemoryPool<byte> PipeScheduler PipeOptions PinnedBlockMemoryPool IOQueue SocketAwaitableEventArgs PipeScheduler var memoryPool = new PinnedBlockMemoryPool();
var applicationScheduler = PipeScheduler.ThreadPool;
var transportScheduler = new IOQueue();
var socketScheduler = transportScheduler;

var receiver = new SocketReceiver(socketScheduler);

var InputOptions = new PipeOptions(memoryPool, 
        applicationScheduler, transportScheduler, 
        maxReadBufferSize, maxReadBufferSize / 2, 
        useSynchronizationContext: false),

var OutputOptions = new PipeOptions(memoryPool, 
        transportScheduler, applicationScheduler, 
        maxWriteBufferSize, maxWriteBufferSize / 2, 
        useSynchronizationContext: false),

var SocketSenderPool = new SocketSenderPool(PipeScheduler.Inline), It can also be seen above and is used for flow control. This is when processing data is more complicated than simply sending it back in which case the reader would allocate more and more memory. When is set however and if the amount of data in the pipe is more than set value will not be completed until it is less than again. PauseWriterThreshold ResumeWriterThreshold PauseWriterThreshold PipeWriter.FlushAsync ResumeWriterThreshold Where to go from here? As I was writing the code for this post some preliminary benchmarks showed that the code presented is actually somewhat slower than a basic Echo Server. Netty would reach 115000 requests per second while code above would reach 110000. It however is a well-established framework, so it shouldn’t be too surprising. This just shows that some proper benchmarks are needed along with profiling and optimization. Netty The full source can be viewed at . the GitHub repo

Building a High Performance TCP Server in C#

REST has long been a popular architectural paradigm for creating , but in recent years has put REST's reign in jeopardy. APIs GraphQL's rise in popularity When it comes to establishing or leveraging API architecture design, the debate between GraphQL and REST is raging, and most firms are split between the two. While REST is generally recognized as the industry standard for creating APIs, GraphQL has been heralded as a new technology capable of overcoming REST's limitations. REST and GraphQL are two data retrieval technologies. The main distinction between GraphQL and RestAPIs is that GraphQL is a query language standard, whereas REST is an architectural idea for network-based computing. We'll walk you through the working process with both options, and you’ll be able to compare which one is more fit for you: GraphQL vs REST. But first, let’s define the terms. GraphQL Explanation GraphQL is a runtime for satisfying queries with existing data, as well as an open-source data query and manipulation language for APIs. GraphQL, which is largely maintained and developed by the GraphQL Foundation, has seen tremendous acceptance across a wide range of verticals and use cases, including companies such as Twitter, Expedia, Shopify, and GraphCMS, to mention a few. By allowing the user to receive just the data they expressly requested, this API architecture design eliminates any performance difficulties caused by extra fetching. Furthermore, many entities can be merged into a single query. GraphQL offers the advantage of tolerating client-side changes without affecting the server, allowing for quick front-end product updates. Developers that utilize GraphQL on the backend obtain a lot of information about any data request and how the available data is being used. You may also be interested in the Graph Database Examples outlook. RestAPI Definition RestAPI today is a much easier technique to enable stateless and type-free machine-to-machine communication using only the ubiquitous HTTP protocol and no other layers. This made it possible for systems to be loosely connected and more tolerant of contract changes between systems, such as between businesses. For firms delivering API architecture design and developing developer platforms, RestAPI has become the de facto norm. The benefit of REST is that it eliminates the need for any specific setup or libraries when interacting with someone else's API. Common tools such as cURL and web browsers can be used to send requests. REST's key advantage is that it is scalable and decouples client and server, enabling developers to work independently on products and applications. It is adaptable to a wide number of forms and can suit a wide range of requirements. Getting Started Now, we can compare both API architecture designs in practice. But, before we start with installation descriptions, you need to install a typical Django project, connect it to PostgreSQL and make migrations. For the following work you also need to provide simple Django models: GraphQL vs REST Store in models.py from django.db import models


class Store(models.Model):
   name = models.CharField(max_length=256, verbose_name='Store name')
   address = models.CharField(max_length=256)
   email = models.EmailField()
   opening_hours = models.TimeField(verbose_name='Opening hours')
   closing_hours = models.TimeField(verbose_name='Closing hours') And Product in another file: models.py from django.db import models
from django.core.validators import MaxValueValidator, MinValueValidator


class Product(models.Model):
   title = models.CharField(max_length=256, verbose_name='Product title')
   description = models.TextField(max_length=5000)
   price = models.FloatField(
       validators=[MinValueValidator(0.0), MaxValueValidator(10000.0)],
   )
   amount = models.SmallIntegerField()
   store = models.ForeignKey('stores.Store', on_delete=models.CASCADE) GraphQL In Django Installation process: pip install graphene-django In file: settings.py INSTALLED_APPS = [
    ...
    "django.contrib.staticfiles", # Required for GraphiQL
    "graphene_django"
]

GRAPHENE = {
    "SCHEMA": "app.schema.schema"
} We need to add a graphql URL to the of your Django project: urls.py from graphene_django.views import GraphQLView

from django.contrib import admin
from django.urls import path
from django.views.decorators.csrf import csrf_exempt

from app.schema import schema

urlpatterns = [
   path('admin/', admin.site.urls),
   path("graphql", csrf_exempt(GraphQLView.as_view(graphiql=True, schema=schema))),
] For querying process (like use GET) you need to provide object types and resolvers: import graphene
from graphene_django import DjangoObjectType
from app.stores.models import Store
from app.products.models import Product

class StoreType(DjangoObjectType):
   class Meta:
       model = Store
       fields = (
           'id', 'name', 'address', 'email', 'opening_hours', 'closing_hours',
       )


class ProductType(DjangoObjectType):
   class Meta:
       model = Product
       fields = (
           'id', 'title', 'description', 'price', 'amount', 'store',
       )


class Query(graphene.ObjectType):
   stores = graphene.List(StoreType)
   products = graphene.List(ProductType)

   def resolve_stores(root, info, **kwargs):
       # Querying a list
       return Store.objects.all()

   def resolve_products(root, info, **kwargs):
       # Querying a list
       return Product.objects.all()

schema = graphene.Schema(query=Query) GraphQL Testing For testing you can just type in your browser: http://127.0.0.1:8000/graphql If you want something to change (create or update) you need to provide inputs and create/update class with arguments and mutation methods: class StoreInput(graphene.InputObjectType):
   name = graphene.String()
   address = graphene.String()
   email = graphene.String()
   opening_hours = graphene.Time()
   closing_hours = graphene.Time()


class CreateStore(graphene.Mutation):
   class Arguments:
       input = StoreInput(required=True)

   store = graphene.Field(StoreType)

   @classmethod
   def mutate(cls, root, info, input):
       store = Store()
       store.name = input.name
       store.address = input.address
       store.email = input.email
       store.opening_hours = input.opening_hours
       store.closing_hours = input.closing_hours
       store.save()
       return CreateStore(store=store)

class UpdateStore(graphene.Mutation):
   class Arguments:
       input = StoreInput(required=True)
       id = graphene.ID()

   store = graphene.Field(StoreType)

   @classmethod
   def mutate(cls, root, info, input, id):
       store = Store.objects.get(pk=id)
       store.name = input.name
       store.address = input.address
       store.email = input.email
       store.opening_hours = input.opening_hours
       store.closing_hours = input.closing_hours
       store.save()
       return UpdateStore(store=store)


class ProductInput(graphene.InputObjectType):
   title = graphene.String()
   description = graphene.String()
   price = graphene.Float()
   amount = graphene.Int()
   store = graphene.ID()


class CreateProduct(graphene.Mutation):
   class Arguments:
       input = ProductInput(required=True)

   product = graphene.Field(ProductType)

   @classmethod
   def mutate(cls, root, info, input):
       product = Product()
       product.title = input.title
       product.description = input.description
       product.price = input.price
       product.amount = input.amount
       product.store = input.store
       product.save()
       return CreateProduct(product=product)

class UpdateProduct(graphene.Mutation):
   class Arguments:
       input = ProductInput(required=True)
       id = graphene.ID()

   product = graphene.Field(ProductType)

   @classmethod
   def mutate(cls, root, info, input, id):
       product = Product.objects.get(pk=id)
       product.title = input.title
       product.description = input.description
       product.price = input.price
       product.amount = input.amount
       product.store = input.store
       product.save()
       return UpdateProduct(product=product)

class Mutation(graphene.ObjectType):
   create_store = CreateStore.Field()
   update_store = UpdateStore.Field()
   update_product = CreateProduct.Field()
   create_product = UpdateProduct.Field()

schema = graphene.Schema(query=Query, mutation=Mutation) Also, you can test creation in the browser: RestAPI In Django Installation process: pip install djangorestframework In file: settings.py INSTALLED_APPS = [
   ...
   'rest_framework',
]

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10
} You should make serializers in : products/serializers.py from rest_framework import serializers

from .models import Product


class ProductSerializer(serializers.ModelSerializer):
   class Meta:
       model = Product
       fields = '__all__' And also, in : stores/serializers.py from rest_framework import serializers

from .models import Store


class StoreSerializer(serializers.ModelSerializer):
   class Meta:
       model = Store
       fields = '__all__' After this you need to make your views: from rest_framework import generics
from rest_framework.permissions import AllowAny

from .serializers import ProductSerializer
from .models import Product


class RetriveUpdateDestroyProductView(generics.RetrieveUpdateDestroyAPIView):
   queryset = Product.objects.all()
   serializer_class = ProductSerializer
   permission_classes = [AllowAny]


class ListCreateProductView(generics.ListCreateAPIView):
   queryset = Product.objects.all()
   serializer_class = ProductSerializer
   permission_classes = [AllowAny] from rest_framework import generics
from rest_framework.permissions import AllowAny

from .serializers import StoreSerializer
from .models import Store


class RetriveUpdateDestroyStoreView(generics.RetrieveUpdateDestroyAPIView):
   queryset = Store.objects.all()
   serializer_class = StoreSerializer
   permission_classes = [AllowAny]


class ListCreateStoreView(generics.ListCreateAPIView):
   queryset = Store.objects.all()
   serializer_class = StoreSerializer
   permission_classes = [AllowAny] And connect it in file: urls.py In app/stores/urls.py from django.urls import path
from .views import ListCreateStoreView, RetriveUpdateDestroyStoreView


urlpatterns = [
   path('<int:pk>/', RetriveUpdateDestroyStoreView.as_view(), name='store-get-update-delete'),
   path('', ListCreateStoreView.as_view(), name='store-post-list'),
] In app/products/urls.py from django.urls import path
from .views import ListCreateProductView, RetriveUpdateDestroyProductView


urlpatterns = [
   path('<int:pk>/', RetriveUpdateDestroyProductView.as_view(), name='product-get-update-delete'),
   path('', ListCreateProductView.as_view(), name='product-post-list'),
] And in app/urls.py from django.contrib import admin
from django.urls import path, include

urlpatterns = [
   path('admin/', admin.site.urls),
   path('store/', include('app.stores.urls')),
   path('product/', include('app.products.urls')),
] RestAPI Testing After this, you can test it in Postman. For getting products: And creating a new store: GraphQL Vs REST If we compare the examples of the two API integration designs, we can see that the implementation of GraphQL requires more description of the logic of creating new objects, and in the RestAPI there are many ready-made solutions out of the box. That is, GraphQL requires a more complex implementation. Instead, GraphQL adds usability. For example, to make a query and get additional fields you need to register them when querying. At the same time for RestAPI, if you need new fields, then the backend needs to implement new serializers. Also, using GraphQL requires fewer queries to get the information you need. This is important when the Internet may not be good enough (for example, on mobile devices that use a mobile network). GraphQL is more focused on the client-side than well-created documentation, which is created independently. However, among the negatives can be called incompatibility with HTTP. You cannot use statuses (only 200 and 500 are used) and methods (POST only). That takes away flexibility in the processing of errors on a client's part. It is also quite problematic to implement caching in GraphQL due to the use of a single endpoint in different queries. As for security, GraphQL needs to be worked on further, because with the help of queries to different graphs, you can make a query to another user through the rock store to which they belong. In REST there is no such problem as the client receives only what is registered in the endpoint. Summary: How To Choose? GraphQL is fairly new compared to RestAPI, and it's easy to use. Its flexibility and high query speed make it a great alternative to RestAPI. GraphQL will be brilliant when you need a quick interface development, and you expect the program to respond quickly and in a short amount of time. REST, on the other hand, is a more suitable solution for more complex programs with more caching and bug reports. It all comes down to your needs. Some APIs, such as analytics APIs, may not be suitable for GraphQL since they have a small number of entities and connections between them. GraphQL may be more useful in applications with a large number of domain objects, such as e-commerce, where you have goods, users, orders, payments, and so on. However, obviously, to make a decision that won’t affect your app’s performance lately in a bad way, it’s better to confide in software development experts. First published . here

GraphQL vs REST - Syntax Comparison

I love . Laravel As a PHP developer with a history of working in everything from WordPress to CodeIgniter, when Laravel came on the scene it was a revelation. From the design to the usability, it is an absolutely top-notch framework that contains untold depths of power. That said, sometimes Laravel's own opinionated structure can get in the way of what can feel like pretty simple intentions, such as adding custom global arguments to all Artisan commands. What do I mean by "custom global arguments?" As an example, Artisan commands have the all same set of arguments and options that can be used during runtime: --raw             To output raw command list
    --format=FORMAT   The output format (txt, xml, json, or md) [default: "txt"]
    --short           To skip describing commands' arguments
-h, --help            Display help for the given command. When no command is given display help for the list command
-q, --quiet           Do not output any message
-V, --version         Display this application version
    --ansi|--no-ansi  Force (or disable --no-ansi) ANSI output
-n, --no-interaction  Do not ask any interactive question
    --env[=ENV]       The environment the command should run under
-v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug But, what if we wanted to add options and arguments? our own A Wild Problem Has Appeared! I've always been a pretty big fan of for both its power and ease-of-use—okay, maybe not so much lately thanks to how poorly they've communicated their most recent , but I've been a fan. Heroku security incident historically One of Heroku's most frustrating drawbacks, though, is how limited the Scheduler is. A kind of half-assed cron, allows you to run any command on 10-minute, 1-hour, or 1-day intervals, which is useful, but also woefully insufficient for many different types of jobs. Heroku's Scheduler kind of What if I only need something run weekly, monthly, or even yearly? Scheduler says "no." So, in order to work around this (within a typical Laravel application), I have traditionally added an additional argument to my Artisan commands that limits running on specific days. For example: php artisan run:command --day=friday Pretty simple design, right? It gets the job done, but it's hardly scalable. Copying the same several lines of " " logic can get pretty tedious (not to mention nothing close to DRY), so I dug into Artisan to better understand how I could add additional global parameters that can be applied to commands, rather than just the ones I specify. if current day == --day parameter, then run, otherwise return 0 all Extending Artisan Thankfully Laravel, being the object-oriented framework that it is, is pretty easy to extend. The challenge isn't so much in the extension as it is in properly writing said extension up into the rest of the application. That said, before we can actually wire up, we first need to extend the class and add our own custom argument. To do this, create a new file called and paste the following code in: anything Console\Application --day ./app/Console/Application.php <?php
namespace App\Console;

use Illuminate\Console\Application as Artisan;
use Illuminate\Support\Str;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class Application extends Artisan
{
    /**
     * Runs the current application.
     *
     * @return int 0 if everything went fine, or an error code
     */
    public function doRun(InputInterface $input, OutputInterface $output)
    {
      if ( !$this->checkDay($input) ) {
        $output->writeln(sprintf('<comment>This command can only be run on %s.</comment>', Str::plural(ucfirst($input->getParameterOption('--day')))), OutputInterface::VERBOSITY_QUIET);

        return 0;
      }

      return parent::doRun($input, $output);
    }

    protected function getDefaultInputDefinition()
    {
        $definition = parent::getDefaultInputDefinition();

        $definition->addOption(new InputOption('--day', null, InputOption::VALUE_OPTIONAL, "Only run the command on the specified day of the week"));

        return $definition;
    }

    public function checkDay(InputInterface $input)
    {
      $day = $input->getParameterOption('--day');

      if ( !$day ) {
        return true;
      }

      return strtolower(now()->englishDayOfWeek) === strtolower($day);
    }
} What the above code is doing can be broken down into a few parts: It creates a new method that gets our custom global parameter ( ) and checks the value against the current day of the week. If the two values are matched (or is not provided), then will return , otherwise it will return . checkDay() --day --day checkDay() true false It extends the method and checks the value of before running the rest of the command. If returns false, the command will immediately and print a comment indicating that the command can only be run on the specified day. doRun() checkDay() checkDay() return 0 Finally, because we want anyone that types to this new argument, we extend and add a new definition indicating that both , and how it works. php artisan --help know about getDefaultInputFunction() --day exists Wiring It Up So, we've extended our console application, but if we were to run our new argument won't show up yet. That's because we need to about our new class, otherwise it will load the original class by default. php artisan --help --day tell Laravel Console\Application To do this, open up and add the following function to the class: ./app/Console/Kernel.php Kernel /**
 * Retrieve the artisan application instance.
 *
 * @return \Illuminate\Console\Application
 */
protected function getArtisan()
{
  if (is_null($this->artisan)) {
    return $this->artisan = (new \App\Console\Application($this->app, $this->events, $this->app->version()))->resolveCommands($this->commands);
  }

  return $this->artisan;
} What the above function does is tell Laravel to load our newly defined class when setting Artisan up, rather than the default class. Because we extended the original class, the existing functionality will still be maintained, but with the new functionality we just added. \App\Console\Application \Illuminate\Console\Application Console\Application Now, if we were to type , we would see a new argument listed in the response: php artisan --help --raw             To output raw command list
    --format=FORMAT   The output format (txt, xml, json, or md) [default: "txt"]
    --short           To skip describing commands' arguments
-h, --help            Display help for the given command. When no command is given display help for the list command
-q, --quiet           Do not output any message
-V, --version         Display this application version
    --ansi|--no-ansi  Force (or disable --no-ansi) ANSI output
-n, --no-interaction  Do not ask any interactive question
    --env[=ENV]       The environment the command should run under
    --day[=DAY]       Only run the command on the specified day of the week
-v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug Fin. That's it! All-in-all, it's a pretty straightforward change with some potentially powerful implications. Also published at flower.codes

Extending Laravel Artisan Commands

Auth requirements are quite varied. Therefore any auth solution must provide the ability to customise their APIs. Each solution uses its own terminology for this feature: Keycloak uses “Implementing a SPI” Auth0 calls these “Auth0 actions” Firebase calls these “Extend using cloud functions” AWS Cognito uses the term “Lambda triggers & Custom challenge” SuperTokens calls this feature “Overrides” These features allow you to change the default behaviour of the auth APIs by: Creating an HTTP webhook in your API layer which is then called by the auth provider Uploading code to the auth provider (for example JS code for Auth0, or Java interface implementation for Keycloak) which run at specific points in the API’s logic. Uploading code to the auth provider which can replace the existing API’s logic entirely (as opposed to just running at specific points in the API) How powerful these solutions are, depends on: The auth provider providing the right “hook points” in their API, where your custom code can run. Your familiarity with the programming language you need to use to write the custom code. How easily your custom code can integrate with your existing infrastructure code (for example database connection setup), and how easily it can be maintained (for example, you may need to maintain the custom code snippets in your git repo as well as on the auth provider’s dashboard). In this article, we will be talking about how to customise the auth APIs provided by SuperTokens using its “Override” feature. In order to understand that, we must first understand how SuperTokens fits within an app. SuperTokens’ architecture Here we can see the architecture diagram for the self-hosted version of SuperTokens. On the left, we have the client (browser, mobile app) which talks to your APIs. Your API layer has your application APIs (shown as /api1/, /api2/, ..) and also APIs automatically exposed by the SuperTokens backend SDKs via our middleware function (shown as /auth/signin, /auth/signout, ...). The SuperTokens APIs talk to the SuperTokens Core (HTTP microservice) to persist data in the database. Your application APIs can also talk to the core if needed. Keeping this in mind, the concept of override is that you can change the behaviour of the SuperTokens APIs (exposed to the frontend) as per your requirements (all within your API layer, in the language you already use). Think of this being similar to overrides in object-oriented programming where you have an original implementation, and you can modify its behaviour by overriding the existing functions. You can even call the “super” class implementation of that function in your override function. Overriding feature in SuperTokens Whilst this article is focused on a NodeJS backend, the concepts here are very similar to all the other backend SDKs provided by SuperTokens. To override the default implementation, we must use the override config value when calling . Each recipe inside the , accepts an override config that can be used to change the behaviour of that recipe: supertokens.init recipeList supertokens.init({
   appInfo: {...},
   recipeList: [
       EmailPassword.init({
           override: {
               functions: (originalImplementation) => {
                   return originalImplementation
               },
               apis: (originalImplementation) => {
                   return originalImplementation
               }
           }
       }),
       Session.init({...})
   ]
}) In the above, we have defined the skeleton code for how to override the behaviour of the EmailPassword recipe. A very similar skeleton is applicable for overriding the Session (or any other) recipe. There are two types of override: APIs: These govern how the APIs exposed by that recipe behave. For EmailPassword, these are the sign in / sign up, reset password and email verification APIs. By overriding these, you can change how these APIs behave when they are called from the frontend. Functions: These are the functions that govern how the recipe itself behaves. They can be called by you manually in your APIs and they are also used in the APIs we expose to the frontend. By default, they query the SuperTokens core and return its response. The difference between the two are: API functions have access to the request and response objects depending on the web framework being used API functions can call several recipe functions or even call functions from multiple recipes. For example, the API function in the EmailPassword recipe, calls the recipe function from EmailPassword recipe and the function from the Session recipe. signInPOST signIn createNewSession You always want to try and use the config since that will make the minimum change to the default behaviour. If the inputs to those functions don’t suffice for your use case, then you should override the APIs. override.functions In both these types of overrides, they accept the variable as an input and the return is an object that has the same type as the . originalImplementation originalImplementaion For EmailPassword recipe, the object contains: originalImplementation For function override (see full type def ): here signIn signUp updateEmailOrPassword createResetPasswordToken resetPasswordUsingToken getUserByEmail getUserById For API override (see full type def ) here signInPOST signUpPOST emailExistsGET generatePasswordResetTokenPOST passwordResetPOST For Session recipe, the object contains: originalImplementation For function override (See full type def ) here createNewSession getAccessTokenLifeTimeMS getAllSessionHandlesForUser getRefreshTokenLifeTimeMS getSession getSessionInformation refreshSession revokeAllSessionsForUser revokeMultipleSessions revokeSession updateAccessTokenPayload updateSessionData For API override (see full type def ) here refreshPOST signOutPOST In the code snippet above, we are not modifying the default behaviour of any of these functions since we are simply returning the object. If you want to modify the function, then we can do so like this: originalImplementation signIn EmailPassword.init({
   override: {
       functions: (originalImplementation) => {
           return {
               ...originalImplementation,
               signIn: async function (input) {
                   let email = input.email;
                   let password = input.password;
 
                   // TODO: some custom logic before
 
                   let originalResponse = await originalImplementation.signIn(input);
 
                   // TODO: some custom logic after
 
                   return originalResponse;
               }
           }
       },
       apis: (originalImplementation) => {
           return {
               ...originalImplementation
           }
       }
   }
}) In the above code snippet, we have provided a custom function that uses the original implementation’s function. As marked above (in comments), we can write custom logic before or after calling the original implementation. signIn signIn TODO If we wish, we can even avoid calling the original implementation entirely and define our own logic. For example, if we wanted to use a different password hashing algorithm that is not supported by SuperTokens. Special cases for modifying APIs Sometimes, you may want to modify the default API to: Access the request object, for example, to read the origin header Send a custom reply to your frontend UI that deviates from our predefined output types Disable an API we have provided entirely. For example, you may want to do this if you do not want users to self sign up in your application. The function signature of all the API interface functions has an parameter that contains the original request and response objects. You can read from the request object and write to the response object as you normally would in your own APIs. options For example, if you want to read the request’s origin header during the sign up API, you can do it as follows: EmailPassword.init({
   override: {
       apis: (originalImplementation) => {
           return {
               ...originalImplementation,
               signUpPOST: async function (input) {
                   if (originalImplementation.signUpPOST === undefined) {
                       throw new Error("should never come here.");
                   }
 
                   let origin = input.options.req.getHeaderValue("origin");
 
                   // TODO: do something with the origin
 
                   return originalImplementation.signUpPOST(input);
               }
 
           }
       }
   }
}) As you can see above, we can access the request object using input.options.req. Likewise, if we want to send a custom response to the frontend, we can access the response object via . input.options.res Finally, to disable an API that we provide, you can set it to as follows: undefined EmailPassword.init({
   override: {
       apis: (originalImplementation) => {
           return {
               ...originalImplementation,
               signUpPOST: undefined
 
           }
       }
   }
}) This will disable the sign up API, and requests to /auth/signup will be passed along to your APIs or yield a 404. Advantages of the override method: Make modifications in the language and web framework you are already familiar with, within your own backend layer. This allows you to reuse your code for connecting to your database, sending a custom reply, logging requests and responses, sending analytics events, handling errors etc. Furthermore, since you already know the language and the web framework, the learning curve is minimal. Easier maintainability: Some auth providers require you to upload code onto their dashboard. This means you need to make sure that changes to that version of the code in your git repo are reflected on the auth provider’s dashboard (and vice versa). This can be a headache, especially with larger team sizes. With SuperTokens, all the mods you will ever need will live in the same codebase as all of your other backend code - SuperTokens is just another library you use. Flexibility in customisations: If you noticed, we don’t provide any special “hook” points (like pre-sign up or post sign up callbacks). You simply create your own implementation based on the original implementation. In fact, you can even copy the original implementation’s code and paste that in your own implementation if required. Hence, your modifications can be at any point in the API logic. In turn, this provides maximum flexibility. Flexibility in integrations: Auth APIs have to interact with several other services like those used for sending emails or SMSs, spam/anomaly detection or rate-limiting. Since the APIs are all within your own backend layer, you can use any such service(s) in the APIs we provide - you are not limited to the ones we (eventually will) support. Conclusion In the post, we saw how we can use the Overrides feature to modify the behaviour of any of the auth APIs exposed by SuperTokens. Whilst this blog focuses on NodeJS, the concept is the same in all the other SDKs we provide. Written by the Folks at — hope you enjoyed! We are always available on our . Join us if you have any questions or need any help. SuperTokens Discord server First Published here

Overriding the SuperTokens APIs for Custom Usecases

Building A Blockchain in Rust & Substrate: [A Step-by-Step Guide for Developers]

According to a , it’s estimated that 62% of the automotive industry is set to utilize blockchain technology for various use-cases by 2021. Some of the most renowned and beloved car brands are tapping into DLT, as Blockchain writes a new chapter for the industry with evangelist confident that the Automotive industry will be next in line to be disrupted by this new nascent technology. report by IBM institute for business value Even more so, 95% of Automotive manufacturers are planning on making ‘’moderate to significant” investments in the technology with Enterprise through endowing startups to aid the development of potential blockchain-based solutions. What’s driving services will be the marriage of Automotive technologies & Blockchain. The technology is set to provide a ‘’much-needed’’ change that’s capable of addressing key issues faced by the struggling automotive industry. At the moment, enterprises are busy testing out blockchain-pilots with the clear intention of driving innovation and solutions across the entire ecosystem, or where it’s most applicable. ‘’Connected car’’ To get a better idea of the disruptive impact of DLT, here are several use-cases in which Blockchain will reshape the automobile industry: Since data integrity plays a vital role in modern finance where problems can arise when an error occurs as the result of manual data entry, facilitating trade, and data management. Distributed Ledger technology (DLT) is meant to streamline these processes, allowing independent parties to keep an accurate record of a vehicle’s lifetime. Commerce: Thousands of parts are needed to manufacture a car, a process which involves an extensive network of individuals, organizations, resources & activities. Due to the complexity of managing large supply chains, parts are essentially at risk of being damaged, stolen, and replaced. By Implementing DLT to further manage the supply chain, companies will have an effective & efficient means of tracking all the components from the day it’s produced, to it being shipped as the final product. Supply Chain: The involvement of Third-parties such as insurance, maintenance, and even cleaning services requires vehicle owner to disclose confidential information. The use of Blockchain allows customers to manage personal data and share that information with third-party service providers. On-demand mobility services (MaaS) through integration of Blockchain, allows various forms of transport services into a single mobility services that’s made accessible on demand. MaaS is often used to describe a shift away from personally-owned modes of transportation and towards mobility solutions, solutions consumed as a service such as Ride-sharing is a good example. Mobility: However, there’s one area in which Blockchain will have the biggest impact and is set to disrupt, which has to do with Connected Car Technologies. The next digital revolution to have a deep impact on the automotive industry will be all about communication and autonomous vehicle. For now, there are several trends that seem to be shaping the future of Connected Cars. The term ‘’connected car’’ is used to describe the digitization of IoT-compatible cars and advances in technology that allow vehicles to communicate & connect with one another over a Network. It’s true that Connectivity will be one of the main factors driving the connected cars development, and Blockchain is set to play a vital role when it comes to improving the quality and speed of vehicle communications. DLT has the ability to store asset ownership rights, settle transactions as part of a globalized payment system, and allow for greater transparent Supply-chain management To give you a better idea as to how Blockchain is applied in this instance, let’s review a number of companies that began implementing this technology to solve existing problems & use Blockchain to introduce a set of new applications. Hyundai Hyundai Motor Group’s subsidiary, Hyundai AutoEver, has announced a formal partnership with Blocko, a South Korean firm that specializes as a Blockchain-as-a-Service (BaaS) provider. Blocko has signed a MoU with Hyundai Motor Group’s ICT platform, with the intention of teaming up to develop an in-house platform for the Automotive giant. With the help of Blocko, Hyundai is applying Blockchain to safeguarding vehicle’s ownership, allowing the tracking of confidential vehicle information such as mileage, service history and age. The BaaS provider also specializes in open-source solutions, introducing Aergo, Blocko’s latest undertaking that is set to allow Enterprises to make greater use of decentralized technology without having to comprise, by introducing a unique Hybrid Blockchain. Hyundai has announced that its platform will be migrating to Aergo Mainnet, giving us a glimpse of a future where Automotive giants are keen to utilize a more open and public blockchain of choice. For now, Hyundai intends to use a blockchain-powered platform for vehicle lifecycle management, Mobility-as-a-Service (MaaS) and insurance. The Hyundai affiliate company that manages the IT for all 54 of Hyundai Motors Group’s systems. You can read more about it . here BMW The german car brand has been supportive of Blockchain back in 2018, publicly announcing that it will use the technology as a way to share self-driving car data among Network participants. In an attempt to utilize valuable data collected by self-driving vehicles, BMW plans to use Blockchain to overcome one of the biggest barriers hindering the mass adoption of autonomous by essentially unlocking data that is being kept in silos. In the past, BMW has collaborated with Blockchain-based startups such as Vechain to work on the firm’s VerifyCar app which designed to entitle each owner, a digital passport of their vehicle. The firm also plans to use the technology to combat manipulated odometers, which is estimated to cost $6.78 billion annually in Germany alone. BMW has also joined the ‘’Mobility open Blockchain initiative’’, a group that was formed with the goal of implementing blockchain to make mobility safer, greener, cheaper and more accessible. In the coming years, BMW will be one of the pioneers in the automotive industry to implement DLT for a number of concepts ranging from supply-chain management, to interconnected autonomous vehicles. Porsche An automobile manufacturer that specializes in high-performance luxury sports cars has partnered up with the Berlin-based startup, XAIN, to test blockchain applications to be integrated in Porsche vehicles. Porsche is said to be the first car manufacturer to implement and successfully test Blockchain according to statements made by company. Over the years, Porsche is said to be piloting the technology for the application of locking and unlocking a vehicle, with the grand idea of letting car owners temporarily give someone access to their car In addition to testing, in the past Porsche has finalized a $170 Million loan using Blockchain, by completing a deal with Banco Bilboa Vizcaya Argentaria’s (BBVA), a Spanish bank known for being a Blockchain advocate and issuing out syndicated corporate loans. Porsche has officially become the first non-Spanish company to complete an acquisition term loan that has been entirely arranged through distributed ledger Industrializing the Blockchain for the Automotive Industry It’s expected that Automotive Industry will benefit from new technological advancements throughout the years and perhaps even write a new chapter for the sector. With the introduction of electric cars, full autonomy and ride sharing services, there is the possibility of a seismic shift that could lead to a future where Blockchain is the ideal solution for the management of data. Leave it to automotive companies to refine and redefine by introducing new, exciting concepts like artificial intelligence and connected cars with the end-goal of giving us a driving experience that will be like nothing we’ve ever known before. existing technologies A tipping point can be expected within the next five years, as there are several factors such as the impact of changes inautomotive ownerships, the release of sales models and the greater acceptance & adoption of Blockchain. For now, DLT is finding its way to apply concrete applications within the automotive sector offering a wide-range of viable solutions. This is a period of pilots and trials, prior to the wholesale adoption of technology since we’re at an early stage.

Blockchain meets the Automotive Industry and it’s disruptive Implications

I feel kind of traitorous saying this given my pretty long history with Vue and React, but I think I have a new go-to frontend framework. Hyperapp is everything that I wanted Elm to be — it’s easy to build code with, highly organized, and state is handled flawlessly. That being said, it’s not as production ready as the aforementioned frameworks, but once it is I can see it being huge. Let’s start with zero on building a Hyperapp app — with tools that are still emerging, I usually go more in-depth. I’ll do the same here for Hyperapp. Getting Started A few weeks ago, I saw a few articles about Hyperapp when they released version 1.0 and surpassed 10,000 stars on GitHub. I looked briefly at the counter “hello world” in their documentation. I really liked how clean and simple it looked, and I wanted to try it out! const { h, app } = hyperapp const state = {count: 0} const actions = {down: value => state => ({ count: state.count - value }),up: value => state => ({ count: state.count + value })} const view = (state, actions) =>h("div", {}, [h("h1", {}, state.count),h("button", { onclick: () => actions.down(1) }, "–"),h("button", { onclick: () => actions.up(1) }, "+")]) window.main = app(state, actions, view, document.body) You can also use JSX instead of calling the function to create elements. That's what I did since I am used to it from React! I looked through the examples on . I ended up using a so that I didn't have to setup webpack for transpiling JSX or have to deal with the setup. It was awesome, I didn't have any issues using it and it came with a file structure that I enjoyed using. h Hyperapp's Codepen boilerplate Hyperapp uses an architecture inspired by Elm’s — it has views, models, and updates. It also follows the functional philosophy, similar to Elm. That means that state is immutable and the actions don’t have side effects. The state management felt more like Redux than standard React, since state is centralized rather than component specific. Also, you do have to use in order to build impure functions. The architecture and setup was smooth to work with and I didn’t have many problems with it at all. thunks Since I’ve worked with Elm, React, Redux, Vue and Vuex in the past, I recognized the patterns and felt fine moving on to the final project after reading the documentation (which is minimal) and looking at the code examples. The Final Project I wanted to build something that would pull from an API — which can be a relatively messy process in Redux. I didn’t have one in mind, so I browsed to try and find one. I ended up using the — I had an idea to make a rotating list of quotes with a search available for the tags on different quotes. This would allow me to interact with the state quite a bit. this list FavQs API The first code that I wrote was the model for the state. I set initial properties for the attributes I needed in my project: export default {quotes: [],term: '',index: 0} Here, something like TypeScript or Flow would have been nice to enforce typing. I’m sure they could be integrated easily enough into a hyperapp project. The quotes were an array of the quotes coming back from the API, the term was the search term if the user specified that, and then the index was the current index of the quote the user was looking at. I had a config file where I defined some constants to use throughout: export const API_URL = 'https://favqs.com/api/quotes/'export const COLORS = ['#DBEBFF', '#FFBBDD', '#e6f9ff', '#BBBBFF', '#F7FFFD', '#fff8e1']export const FONT_COLORS = ['#62D0FF', '#FF62B0', '#33ccff', '#5757FF', '#03EBA6', '#ffb300'] I also made a services file that held Axios (a minimalist AJAX library) requests for my searches: import axios from 'axios'import { API_URL } from './constants' const getRequest = url => {return axios.get(url, {headers: {'Authorization': `Token token="XXXXXXXX"`}}).catch(err => console.log(err))} export default {getAll: _ => getRequest(API_URL),getQuery: query => getRequest(API_URL + `?filter=${query}&type=tag`)} The above files are framework agnostic, but I wanted to include them for context. Potentially the most crucial file held the actions: import request from '../config/request' export default {getQuotes: quotes => (state, actions) => request.getAll().then(actions.setQuotes),submitSearch: quotes => (state, actions) => request.getQuery(state.term).then(actions.setQuotes),setQuotes: res => ({ quotes: res.data.quotes.filter(quote => quote.body && quote.body.length < 150) }),updateSearch: ({ term }) => ({ term }),next: e => ({ index, quotes }) => ({ index: index + 1 }),prev: e => ({ index, quotes }) => ({ index: index - 1 })} I used thunks for and -- meaning that I just actions a function from a function rather than a value. This allows for impure functions within the nested function, especially since the data from APIs is less predictable than functional programming requires. Since the Axios requests take a bit to execute, the state isn't actually updated until the method is called after the data is fetched from the API. The other actions are relatively straight forward! The event handlers do take the event first and then the current state afterwards -- I did find this a bit "magic-y" but overall the experience with the actions was very smooth. getQuotes submitSearch setQuotes Finally, I created the views. The main view looked like this: import { h, app } from 'hyperapp'import Search from './Search'import Quote from './Quote'import { COLORS, FONT_COLORS } from '../config/constants' const quote = (quotes, index) => quotes[index]const color = index => COLORS[index % COLORS.length]const fontColor = index => FONT_COLORS[index % FONT_COLORS.length] export default ({ quotes, index }, { getQuotes, updateSearch, submitSearch, next, prev }) =><divoncreate={getQuotes}className={ quotes ? 'body' : 'body hidden' }style={{ 'backgroundColor': color(index), 'color': fontColor(index) }} <div className='centered-content'>  
  <div className='container'>  
    { index > 0 &&  
    <div  
      onclick={prev}  
      className='direction left'  
      style={{ 'color': fontColor(index) }}>  
        &lt;  
    </div> }  
    { quotes.length > 0 && <Quote quote={quote(quotes, index)} /> }  
    { index < quotes.length - 1 &&  
    <div  
      onclick={next}  
      className='direction right'  
      style={{ 'color': fontColor(index) }}>  
        &gt;  
    </div> }  
    <Search  
      updateSearch={updateSearch}  
      submitSearch={submitSearch}  
    />  
  </div>  
</div> </div> It looks essentially identical to a functional component in React! The event handlers are lower case, but otherwise the JSX is the same. Lifecycle methods are also a little bit different. I would normally use method in React to make an API request, but here I used the attribute instead. They do essentially the same thing, but the syntax is different. I also didn't see documentation for subscriptions, which are important in Elm. They allow you to use Websockets and add global event listeners. Some of the GitHub issues mentioned them, though, so I would assume they are implemented but not in the documentation yet. componentDidMount oncreate I also had two “subcomponents”, the quote one was very simple: import { h, app } from 'hyperapp' export default ({ quote }) =><div className='quote'><h1>{quote.body}</h1><h4>{quote.author}</h4></div> The search one was as well: import { h, app } from 'hyperapp' export default ({ updateSearch, submitSearch }) =><div className='search'><inputonkeyup={e => {e.keyCode === 13 ? submitSearch() : updateSearch({ term: e.target.value })}}placeholder='Search quote tags...'/></div> Finally, the combined the elements from the other files so that state could be used within the actions and the views. index.js import { app } from 'hyperapp'import actions from './actions'import state from './state'import view from './components/View' app(state, actions, view, document.querySelector('.hyperapp-root')) This binding is essentially identical to how Elm combines the elements! I liked splitting my code into multiple files, and I thought that it was really scalable. I could definitely see myself building something bigger with HyperApp in the future. Next Steps Again, Hyperapp is one of my favorite tools I’ve learned recently — next to maybe Golang. I found it to be a nearly perfect marriage of tools that I’ve used in the past. It is also a tiny library and is super efficient, which is exciting especially in comparison to Angular, which I learned last week! Its API is so minimalistic and it enforces functional programming so well. I would definitely recommend learning it as an onramp to React with Redux. I would 100% use HyperApp again, I found it straightforward and I really liked the elegance of the code. I do hope that the community keeps expanding, the documentation improves, and a Redux/Elm like rewind feature is implemented. Otherwise, I had an excellent experience with Hyperapp and I am already planning on using it again! App Code Part of my On Learning New Things Series Other Similar Articles: Learning Elm Learning Angular5

Functional Programming in JavaScript with Hyperapp

What’s Markdown? Markdown is a lightweight markup language with plain text formatting syntax. It is designed so that it can be converted to HTML and many other formats using a tool by the same name.from Wikipedia Introducing the markdown formatting ⛷ 1. Heading # h1## h2### h3standard 2. Emphasis *Italic type***Bold** Negative 3. Fold Fold the long sentences. <details><summary>Boostnote is a notepad corresponding to markdown notation, which is a tool for organizing and sharing information.</summary>- Features - <br>· Search function to find memos in one shot· Supports markdown notation <br>· Support for Mac, Windows, Linux, iOS, Android <br>· Export and import to Plain text (.txt), Markdown (.md) format <br>· Supports PDF saving <br>· Can be used offline <br>· Synchronize to dropbox etc. with setting <br>· Supports theme colors and numerous fonts <br></details> 4. List - List 1- List 2* List 3* List 4 5. Link Put a text on the left and a url on the right. [Boostnote](https://boostnote.io) 6. Check box - [x] Task 1- [ ] Task 2 7. Quotation > Quotation> Quotation Quotation 8. Horizontal line * * ****-------- 9. Image ![Image title](https://boostnote.io/assets/img/logo.png) 10. Source code Render: function () {Return (<div className="commentBox"><h1> Comments </h1><CommentList data={this.state.data} /><CommentForm onCommentSubmit={this.handleCommentSubmit} /></div>);} 11. Table Fruits Price Apple 1$ Grapes 4$ Orange 2$ Lemon 1$ Peach 3$ Melon 20$ These are the basic markdown formatting.In addition to above, you can also complex formatting like following in . Boostnote Latex Mathematical formatting. $$$\mathrm{e}^{\mathrm{i}\theta} = \cos(\theta) + \mathrm{i}\sin(\theta)$$$ Flowchart st=>start: Start:>http://www.google.com[blank]e=>end:>http://www.google.comop1=>operation: My Operationsub1=>subroutine: My Subroutinecond=>condition: Yes or No?:>http://www.google.comio=>inputoutput: catch something…st->op1->condcond(yes)->io->econd(no)->sub1(right)->op1 Sequence Title: Here is a titleA-> B: Normal lineB -> C: Dashed lineC -> D: Open arrowD -> A: Dashed open arrow That’s all. Enjoy Markdown ;) Curated by Boostnote GitHub Twitter Facebook group

Boost your productivity using Markdown.

In this post, I want to show how you can build the front and back end of a website using NodeJS for the back end. We’ll use node to create endpoints, and set up a database in JSON format. Then, we’ll create a front end application using React that will post to the database, and also fetch data from it. For this example, I’ll be making a guestbook, where users can submit their names and leave messages. Because users won’t need to log in, or retrieve any data, I won’t need to store anything in a session. Here’s the way this will likely work: Basically, we will have this all one one page, with a form for submitting a message, alongside the actual guestbook. To make this work we’’ll start by creating the endpoints for our POST and GET requests. We’ll set up our database, deploy it, so that we can create a React app, and pull data from the online API. Here’s the order in which I like to do things. You may prefer to work differently. This process makes sense to me, because each step builds on the step before it. During this tutorial, I’ll go through each step in more detail. To see how the finished project could work, here’s a link to my project: http://ethan.jarrell.webdeveloper.surge.sh/GuestBook STEP 1 - Our database collection will contain 2 items: The name of the user The message the user writes If you haven’t already done so, go ahead and install MongoDB, and get it running on port 27017. Then, on the command line, we’ll create the database. We’ll call our database signatures. And the collection, guest_signatures. > Show dbs> Use signaturesswitched to db signatures> show collections> db.createCollection(guest_signatures) Now that we have that set up, we can switch to the text editor, and create the models for the database. STEP 2 - Use the command line to start a new express app. Make the new directory, and then use npm init to create the app. This will automatically create your pkg.JSON file. Since this will be a very basic app, we’ll only need 2 other files in our express app. One for our routes. I like to include all my dependencies in this file as well. Then our second fill will be for our models/schema. We’ll tackle the model file first. It should look something like this: const mongoose = require('mongoose'); let Schema = mongoose.Schema; const signatureSchema = new Schema({guestSignature: {type: mongoose.Schema.Types.Mixed,required: true,},message: {type: mongoose.Schema.Types.Mixed,required: true,},}) const Signature = mongoose.model('Signature', signatureSchema); module.exports = Signature; STEP 3 - Before we create our endpoints here, let’s go ahead an list our dependencies at the top of our file. We don’t need too many. //== =// LIST DEPENDENCIES const express = require('express');const parseurl = require('parseurl');const bodyParser = require('body-parser');const path = require('path');const expressValidator = require('express-validator');const mongoose = require('mongoose');const Signature = require('./models/signature.js')const app = express();const url = 'mongodb://localhost:27017/signatures'; //=========================// You don’t necessarily need to connect with mongoose, so feel free to use MongoClient, if you prefer that. We’re also using the Signature schema that we just created in the previous step. Now, let’s create our endpoints. We only have one model, and we’re only going to read and write to it for now, so we’re only going to have 2 endpoints. Our root directory “/”, where we’ll redirect to our API Our api, we’ll call “/api/signatures, where we’ll read and write to. At our API endpoint, we’ll have a GET and a POST. We’ll reference our models, using the find() and create() methods for GET and POST respectively. And our response will need to be in JSON format, so that we can easily access the data there from React later on. Here’s how those endpoints might look: //== =// ROOT DIRECTORY app.get('/', function(req, res) {res.json('you did it');}); //==========================// //== =// GET ALL SIGNATURES app.get('/api/signatures', function(req, res) {Signature.find({}).then(eachOne => {res.json(eachOne);})}) //==========================// //== =// POST NEW SIGNATURE app.post('/api/signatures', function(req, res) {Signature.create({guestSignature: req.body.SignatureOfGuest,message: req.body.MessageofGuest,}).then(signature => {res.json(signature)});}); //==========================// The only thing I didn’t really mention was the req.body.SignatureOfGuest and req.body.MessageofGuest. Everything else in this section refers to something we’ve already created, like our database, collections and models. This refers to the name of the field that we’ll use in our React App, Our input will have to use the names SignatureOfGuest and MessageofGuest, so we’ll need to remember that. STEP 4 - Now, we’ll want to connect to our local database from out text editor. If you remember, we had this constant in our list: const url = 'mongodb://localhost:27017/signatures'; We’ll write a function using this constant to connect to our local database. //== =// MONGOOSE CONNECT mongoose.connect(url, function (err, db) {if (err) {console.log('Unable to connect to the mongoDB server. Error:', err);} else {console.log('Connection established to', url);}}); //==========================// In order to make sure everything is working properly, we’ll also need to add an app.listen at the end of our file. At this point, it’s a good idea to pause, and make sure the endpoints and local connection works. You can do that by using Postman to make GET and POST requests. If the endpoints or connections don’t work, you should be able to diagnose the problem here based on the error messages you receive. If everything is working, it should allow you to appropriately read and write to the database. Once everything is working, it’s time to set up our account on Heroku and Mlab. STEP 5- Sign up for a Heroku account . And create an mLab account . here here STEP 6 - After creating your mLab account, click on the Create New button and select a Single node sandbox. There are paid options as well, but the sandbox has plenty of space for getting started. Give your database a name. Since my local database is signatures, I’m using the same name for my mLab database. Now that you have your database created, you can start a new collection from here. You will also need to add a User or Users who can access your database. Without doing this step, and adding yourself as a User with access, authentication will always fail when you try to deploy it. Now your database is running on mLab. When you click on the database, you should see some information at the top, telling you how to integrate the connection. It should look something like this: mongodb://<dbuser>:<dbpassword> 9234.mlab.com:9234/signatures @ds7 The actual url of the database will just have the username and password replaced with your username and password. Now let’s head back to our text editor. We currently have the database running locally at this location: const url = 'mongodb://localhost:27017/signatures'; To change it, so that we are connected to mLab, simply update the url variable with the information from mLab. It should look something like this: const url = 'mongodb://username:password@ds79234.mlab.com:9234/signatures'; However, you’ll likely be putting this on github, or another public place. You don’t want your mlab username and password in a public sphere where anyone can see it. To fix that, we’ll set an environment variable on the command line, and then update our url variable one more time in the text editor. On the command line, use this command: export MONGOLAB_URI="mongodb://username:password@ds79234.mlab.com:9234/signatures'; Of course, replacing it with your own username, password, numbers and database name. Now, back in our text editor, we will change our url variable to the following: const url = process.env.MONGOLAB_URI; We’ll also want to change our app.listen to reflect the new port. It could look like this: app.listen(process.env.PORT || 3000);console.log('starting applicaiton.  Good job!'); This way, it will try to run from mongolab, but if it can’t make the connection, it will still listen on port 3000 by default. This will also allow you to run the app locally or from mlab, in case you want to test changes on the local version. The final step in making the connection is deploying your code to your Heroku App. to do this, you can use the following code from the command line: heroku config:set MONGOLAB_URI=mongodb://username:password@ds79234.mlab.com:9234/signatures Your app should be successfully deployed on heroku, and you can open it from there now. If you are getting errors, double check to make sure it’s running locally. If so, then it’s probably an error along the way in the connection. In these last two steps, there’s quite a bit of repetitive code. I’m going to outline the high level code here. STEP 7 - Use ‘create-react-app’ from the command line to create a new react app. STEP 8 - Now, we’ll want to create a form, to allow for user input. Here’s how we do that. In a new component, we’ll create a new class. class GuestBook extends Component 2. We’ll use a constructor and super method to pass props down. constructor(props) {super(props); 3. Use the this keyword to handle the name and message of guest, and bind it to (this). this.handleSignatureOfGuest = this.handleSignatureOfGuest.bind(this);this.handleMessageofGuest = this.handleMessageofGuest.bind(this); 4. Set the state of the name and message of guest to an empty string. this.state = {SignatureOfGuest: "",MessageofGuest: "",}; 5. Listen for an event on the state of both the name and message input. handleSignatureOfGuest(event) {this.setState({ SignatureOfGuest: event.target.value });}handleMessageofGuest(event) {this.setState({ MessageofGuest: event.target.value });} 6. Create a function that changes the name and message to the value of the target input. addToGuestBook = event => {event.preventDefault();this.setState({SignatureOfGuest: event.target.value,MessageofGuest: event.target.value,}); 7. I’m now using axios to post the input data to our database, which is on heroku. axios.post('< , {SignatureOfGuest: this.state.SignatureOfGuest,MessageofGuest: this.state.MessageofGuest,}).then(response => {console.log(response, 'Signature added!');}).catch(err => {console.log(err, 'Signature not added, try again');}); your-heroku-url here>' 8. Then I’m resetting the state of the input to an empty string. this.setState({SignatureOfGuest: "",MessageofGuest: "",});}; 9. Finally, we’ll make a render method, and return our page with the input fields. Inside the input of each field, we’ll give it an onChange, name, and value. the onChange will be set to the.handlemessage or this.handlename, for each field. The name of each field will be set to what we called it in our node app. The value will use state, and we’ll set that to this.state.message, and this.state.name. <inputonChange={this.handleSignatureOfGuest}name="SignatureOfGuest"className="NameinputForm"value={this.state.SignatureOfGuest}placeholder="Enter your name"/><textareaonChange={this.handleMessageofGuest}name="MessageofGuest"className="MessageinputForm"value={this.state.MessageofGuest}placeholder="Type a message"/> 10. Then we’ll add a submit button, where we call the function from earlier. <buttonclassName="submitbuttonguestbook"type="submit"onClick={this.addToGuestBook}>Submit to Guestbook<i className="GuestBookButton2" aria-hidden="true" /></button> STEP 9- Now we’ll make another component where we’ll render the data that’s being stored in our database. Then we can export that component, and put it on our guestbook page. Inside this component we’ll do the following: In a new component, we’ll create a new class. class GuestNames extends Component { 2. We’ll use a constructor and super method to pass props down. constructor(props) {super(props); 3. Use this.state to set the state of our guestbook messages to an empty string. this.state = {messages: "",}; 4. Use a componentDidMount lifecycle method componentDidMount() { 5. Inside that method we’ll use fetch and the url of our heroku api to fetch the information from the database. fetch('<your-heroku-url-goes-here> ).then(results => {return results.json(); ' 6. We’ll map over the data, and return the data we want. data.map((msg) => {return(<div key={msg.results}><h3 className="h3msg">{msg.message}</h3> <h2 className="h2sig">-{msg.guestSignature}</h2></div> 7. Now we’ll use this.setState to set the state of the messages to the new state using the data we just fetched. this.setState({messages: messages}); 8. Now we’ll create render mehod. render() { 9. Inside the render method, we’ll create JSX elements to render our data inside the component. I’m using this.state.messages inside an <h6> tag. return ( <div className="guestdataContainer"><h6>Guestbook Messages</h6>{this.state.messages}</div> 10. Finally, we’ll export the component, so we can use it on other pages. export default GuestNames; Again, if you have any questions feel free to reach out. Thanks!

How To Combine a NodeJS Back End with a ReactJS Front End App.

I’m a developer. I like text editors. I like code. I like markup. Like many 90s kids, my early skills were forged in the fires of , and . Finding the right mix of WYSIWYG (What you see is what you get) web development seemed to be the theme of the decade. Since then, the consensus for UI work has moved aggressively towards written . Adobe Dreamweaver Microsoft FrontPage, GeoCities markup On one hand, we have and doing great things with WYSIWYG. Despite that, most developers choose to write their own user interfaces. The elegance, the speed, the simplicity, the hotkeys. For my part, I just don’t like dragging and dropping things with unsteady hands. Wix Squarespace Inc. It’s for this reason that I experimented recently with the goal of text-based, browser-rendered flowcharts. A web search brought me to a number of sophisticated WYSIWYG tools like , , and . For founders and creatives alike, I don’t doubt the power of these tools. It’s just that I wanted the developer-friendly solution. I wanted text input, default colors, and default layout. LucidChart Creately Draw.io Enter . This was the library I wanted. It had a simple, text-based data schema that could be consumed by the library. The sample routine on the site looks something like this: flowchart.js JavaScript flowchart.js st=>start: Starte=>endop1=>operation: My Operationsub1=>subroutine: My Subroutinecond=>condition: Yesor No?io=>inputoutput: catch something... st->op1->condcond(yes)->io->econd(no)->sub1(right)->op1 And it produces: I was extremely happy with the outcome. No more drawing lines, no more determining how to draw a shape, no more deciding relative size and distance. Learning the specifics of the data schema takes a few minutes. It’s elegant and sophisticated enough for my use cases. Here is a more complicated example from the site: flowchart.js st=>start: Start|past:> ]e=>end: End|future:> op1=>operation: My Operation|pastop2=>operation: Stuff|currentsub1=>subroutine: My Subroutine|invalidcond=>condition: Yesor No?|approved:> c2=>condition: Good idea|rejectedio=>inputoutput: catch something...|future http://www.google.com[blank http://www.google.com http://www.google.com st->op1(right)->condcond(yes, right)->c2cond(no)->sub1(left)->op1c2(yes)->io->ec2(no)->op2->e With the configuration styles, it produces: Flowcharts are an incredibly powerful way to model user experience and product flow. Developers should keep a process like this handy in order to dispel present or future arguments. Product people and designers should consider the possibility of moving to text-based flowcharts. provides loads of configuration options for colors and appearance. While I encourage you to explore these, they are outside of my use case. My job is building products and stopping arguments. Haven’t seen a case where black & white couldn’t do the job. Flowchart.js For anyone attempting to create a quick, text-based flowchart, I have created a simple web application at . I was using the seed project locally, so it made sense to open up the use case. textflowcharts.com For anyone attempting to replicate the project, I have assembled a seed project . Clone or download the repo. Run a quick or then and you’ll be off to the races. The project pulls data from the data/sample.txt file. You should edit that to match your flow. here npm install yarn, npm start I welcome any contributions to the project. It’s very simple, and I’d like the keep it that way. My hope is that developers, designers, and product people find a use case for the seed. Special thanks , creator of flowchart.js. It’s a very awesome project and I am glad he built it. Adriano Raiano

Quick, text-based flowcharts for developers

tl;dr: Fare lo sviluppatore in Italia è il più delle volte un incubo Fra tutti i report disponibili, nessuno analizza nel dettaglio lo scenario italiano Abbiamo deciso di farlo noi con un questionario che trovi qui: https://goo.gl/eWDECC E’ anonimo, richiede circa 5–8 minuti e i risultati saranno pubblicati entro fine anno L’iniziativa è legata al progetto Jaguar28 : il nostro obiettivo è riscrivere, in meglio, il rapporto fra professionisti del tech ed aziende 😉 Se hai aperto questo articolo poiché indignato dal titolo, inizia dalla parte finale “PRO TIPS / FAQ / DISCLAIMER” e poi leggi il resto Se lavori in ambito tech, quante volte hai già sentito la frase “ ”? E quante volte ti sei sentito d’accordo? Essere uno sviluppatore in Italia fa schifo Il mercato del lavoro per chi si occupa di sviluppo e programmazione in Italia è “famoso” per essere fra i più arretrati in Europa: tutti lo sappiamo e tutti ci rendiamo conto di trovarci di fronte ad un disagio strutturale che può solo peggiorare con il tempo. Il problema non riguarda solo i salari (i più bassi dell’Unione Europea, insieme a Portogallo, Spagna e Grecia) ma più in generale la concezione del ruolo di “developer” all’interno delle aziende. Per ogni storia romanticheggiante di qualche ragazzino californiano che diventa miliardiario grazie ad una app e viene intervistato da tutti i giornali, in Italia ci sono decine di storie molto meno piacevoli su aziende che non conoscono orari, non investono su innovazione e formazione e credono di poter disporre liberamente della vita dei propri collaboratori. L’intramontabile convinzione del “ ” è infatti anche parzialmente accettabile ma perde ogni legittimazione quando il professionista è sbattuto in uno scantinato a fare il refactoring di progetti vecchi di decenni scritti in Fortran (o quasi) e viene considerato come un pericoloso sovverviso quando si prende un permesso per partecipare ad un seminario. i salari in Italia sono più bassi perché la vita è meno cara Per fortuna esistono già alcune startup ed aziende che hanno compreso l’importanza di questi professionisti e che, per quanto possibile, cercano di garantire loro le condizioni più stimolanti: sono ancora casi isolati — in genere in quei contesti con un’elevata competizione per attrarre i migliori talenti — ma da qualche parte dovremmo pur partire. In tutto questo non dobbiamo dimenticare la crescente categoria dei professionisti italiani che vanno a vivere e lavorare all’estero. Troppo spesso vengono liquidati con un “ ”, anche se non se ne conosce l’effettiva situazione. : esistono sviluppatori italiani che vivono all’estero e sono sottopagati anche lì! loro sì che hanno fatto bene ad andarsene, bravi! NOTIZIA SHOCK Ecco quindi spiegato il grande paradosso: oggi sono moltissimi i professionisti che si lamentano della situazione italiana, ma non esiste nessuna vera analisi a tal proposito. Ogni anno sono pubblicate ricerche davvero apprezzabili sul mondo degli sviluppatori (quella di Stack Overflow è in genere la più completa) che però considerano l’Italia un mercato periferico e che non merita di essere valutato nel dettaglio. Ci siamo quindi chiesti: Qual è il salario medio degli sviluppatori italiani? Quali sono le tecnologie che utilizzano, quelle che vorrebbero utilizzare e quelle che invece vorrebbero dimenticare? Quali sono i fattori di soddisfazione ed insoddisfazione in azienda? Per trovare una risposta, abbiamo deciso di lanciare una nostra survey e condividere pubblicamente la fotografia che emergerà. L’obiettivo è creare una coscienza collettiva sull’argomento e provare ad influenzare il cambiamento, mettendo sul tavolo dati concreti ogni volta che un’azienda si chiederà perché non riesce a trovare sviluppatori in gamba. Il questionario è disponibile qui: https://goo.gl/eWDECC Se hai almeno 1 anno di anzianità come developer, sistemista, QA tester, DevOps e ruoli simili, lavori full-time in Italia o sei un italiano all’estero e hai voglia di dedicare 5 minuti del tuo tempo per aiutarci, questo è il questionario che fa per te. Il questionario è totalmente anonimo e non ti chiederemo indirizzi email o informazioni sensibili riconducibili direttamente a te. Entro fine anno pubblicheremo i risultati. Questa iniziativa è legata al progetto : siamo una startup di Torino e il nostro obiettivo è riuscire a riscrivere, in meglio, il rapporto fra professionisti del tech ed aziende. Qualche mese fa abbiamo già pubblicato un per raccontare come vorremmo farlo. Jaguar28 Manifesto Se hai domande, puoi scriverci a hello@jaguar28.com Grazie! MILESTONES: Lancio della survey: 11 luglio 2017, ore 14.00 Risposte inviate nelle prime 24 ore: 254 Visualizzazioni nelle prime 24 ore: 976 🏆_:_ 1000 risposte 14 luglio 2017, ore 14.19 PRO TIPS / FAQ / DISCLAIMER: Se ti va, condividi questo articolo e/o la survey anche con i tuoi contatti! Se vuoi condividerlo nei tuoi gruppi facebook, chiedi prima il permesso agli admin per non farci passare come spam 😅 Il questionario non chiede mai il tuo nome o il tuo indirizzo email, quindi è un database che non potrà mai finire nelle mani di qualche scammer o, peggio, di qualcuno che non conosce la differenza fra Java e Javascript. Sappiamo che, da un punto di vista metodologico, il report è pieno di possibili bias. Non abbiamo tuttavia la presunzione di volerlo presentare all’ONU in seduta plenaria. O forse sì? Stack Overflow ha parlato di alcuni aspetti dello scenario italiano nella Developer Survey del 2016 (% di remote worker, età media, importanza del salario), rispetto ad un campione di circa 1000 profili italiani. Nella Developer Survey 2017, Stack Overflow analizza USA, India, UK, Francia e Germania ma non l’Italia (da cui ha ricevuto circa 900 risposte). Ci è stato detto che l’AICA (Associazione Italiana per l’Informatica e il Calcolo Automatico) distribuisce annualmente un report abbastanza simile. Noi purtroppo non siamo riusciti a reperirlo da nessuna parte. In autunno lanceremo la controparte volta a raccogliere il punto di vista delle aziende tech. Non invieremo i risultati attraverso una newsletter perché sappiamo che la privacy è top concern e non vogliamo lasciare spazio a nessun tipo di insinuazione su come potremmo usare i vostri indirizzi email. I risultati verranno pubblicati con un post su questo profilo e riproposti nei gruppi dove abbiamo già postato questo articolo. Il titolo è volutamente provocatorio (o clickbait, se volete un termine Internet 3.0) per una ragione molto semplice: la maggior parte della dev community italiana si attiva solo quando il flame è alle porte. : il titolo è una provocazione, non una conclusione. RIPETO Commentare l’articolo e/o l’iniziativa solo in base al titolo senza averne letto per intero il contenuto equivale a condividere con toni indignati i link dei siti di fake news. Se il tuo sesto senso ti fa percepire una truffa, una fonte di speculazione o una cospirazione degli Illuminati non sei obbligato a completare il questionario né a condividere pubblicamente le tue paranoie. Se la cosa ti rende più sereno: sì, siamo Rettiliani e tu ci hai scoperto.

Stories, News & Mentions about INCUTO

Incuto’s Stories on HackerNoon

Incuto's News & Mentions