Skitsanos Design

I also come from a time when ColdFusion was a thing; the one you've mentioned is almost 20 years old—it should already be a sign for you.

I would definitely go with Flask; here are some key reasons why Flask is a better choice than ColdFusion for this simple CRUD application:

Flask is a modern Python web framework actively maintained and supported by many developers. On the other hand, ColdFusion is an older technology that is less widely adopted or actively developed.

Flask is a lightweight, minimalistic Python web framework that is easy to learn and set up, especially for small projects like this one.

Cross-Platform and Language: Flask is a Python-based framework, making it cross-platform and compatible with multiple operating systems. ColdFusion, being a proprietary Adobe product, is primarily focused on Windows environments.

Flask is an open-source framework and doesn't require any licensing fees, making it a cost-effective solution. ColdFusion, however, comes with a significant upfront cost for licensing, which may not be justifiable for a modest application with only a few users.

While the current application is small, Flask offers better scalability options if the project grows in the future. With its modular design and the vast ecosystem of Python libraries, Flask can be extended and scaled more easily than ColdFusion.

Python and Flask have a larger developer community and a wealth of learning resources, making finding support, hiring developers, and accessing third-party libraries and tools easier. ColdFusion has a relatively smaller community and fewer resources available.

Flask integrates well with modern technologies and tools, such as containerization (Docker), cloud platforms (AWS, GCP, Azure), and data stores (SQL and NoSQL databases). This makes it easier to adopt modern development practices and architectures.

By choosing Flask and Python, the client is investing in a modern and actively developed technology stack that is less likely to become obsolete or unsupported in the future. This ensures better long-term maintainability and extensibility.

If you want to play with Flask, you can grab my template from https://github.com/skitsanos/flask-dynamic-routes. It covers API endpoints and web app pages. You just modify/add your own endpoint handlers on the /routes folder where each HTTP method is represented with relevant files, like get.py, post.py, and so on. It also shows you how to use path parameters and a basic login functionality already implemented to showcase how to use sessions.

I spent years and years with Eclipse, and did VS Code as well, but nothing can compare with JetBrain's line of products. I have been coding since 1992, so I have a long list of IDEs I had my hands on, including developing a couple of IDEs of my own.

JetBrains IntelliJ IDEA stands out as a superior choice for Java programmers compared to Eclipse or Visual Studio Code for several compelling reasons. Firstly, IntelliJ IDEA's intelligent code editor significantly enhances productivity by offering advanced code navigation and comprehensive refactoring support. This intelligence extends to real-time code analysis, which can detect potential errors and suggest fixes as you type, thus streamlining the development process.

Another key advantage is the seamless integration with modern frameworks and technologies. IntelliJ supports a wide range of Java frameworks and provides out-of-the-box integration with tools like Maven, Gradle, and version control systems, which can be more intuitive than in Eclipse or Visual Studio Code. This makes it easier for developers to manage projects and dependencies, as well as to maintain a smooth workflow for continuous integration and deployment.

IntelliJ IDEA's user interface is designed to maximize developer productivity by offering a more intuitive and responsive experience. It provides a cleaner, more organized workspace than Eclipse, and many users find its interface to be more navigable and less cluttered. This focus on user experience reduces the learning curve for new users and enhances efficiency for seasoned developers.

The availability of the IntelliJ IDEA Community Edition is a significant advantage, offering a free, open-source version of the IDE. This makes it accessible to a wide range of developers, from students to professionals, without the need for an initial financial investment. The Community Edition includes many of the core features necessary for Java development, making it an excellent choice for those looking to develop pure Java applications or server-side code.

You can grab IDEA from here https://www.jetbrains.com/idea/

Since you are already on GCP, why not use their storage service for that? Another option would be to build your cluster with GCP computing instances and MinIO (https://min.io/) or to go with Backblaze (https://www.backblaze.com/). In both cases, you have an S3-compatible API; just with MinIO, you have more things available, like custom policies, hooks, and various integrations. And it is fast. Like very fast.

Lately, with all that AI buzz, langchain and all, I had to do a lot of Python work, where each service runs as a REST API end-point. Obviously, I wanted to go the “dynamic routing” way, as I did on Foxx Builder (https://github.com/skitsanos/foxx-builder) and other projects, so I needed Flask to handle my route handlers exactly the same way. I went with Gunicorn initially; you can even see it here: https://github.com/skitsanos/flask-dynamic-routes. But it all was fine until its multithreading backfired when I wanted to run it in containers. Azure libs that I used didn't like how it worked, and I needed a bunch of containers behind the load balancer. I had to migrate to Waitress, and my headaches were gone.

Waitress is single-threaded, which means it serves requests in a sequential manner, one after another. This makes it easy to reason about how your application handles concurrent requests.

Gunicorn, on the other hand, uses multiple worker processes (usually multiple threads within each process) to handle concurrent requests. While this can improve concurrency and performance, it can also introduce synchronization and thread safety complexities in your application code.

Waitress is designed to be a simple, production-ready WSGI (Web Server Gateway Interface) server that's easy to set up and use. It's a pure-Python server that doesn't require any additional configuration or management.

Gunicorn, while powerful and feature-rich, can be more complex to set up and configure, especially if you need to manage multiple worker processes. In my case, I didn’t need all that fancy stuff. Gunicorn sounded to me like a swiss-knife, when, in my case, I just needed a simple butter knife.

Waitress is a lightweight server with minimal overhead. It doesn't have as many features as Gunicorn, but it's often sufficient for smaller applications and can be a better choice when you want to keep your server footprint minimal.

Gunicorn is a more heavyweight server with more features and options. This can be advantageous for larger applications with high traffic, but it may be overkill for simpler projects.

Some of my things are offloaded to OpenResty directly, so Lua handles things even before it reaches the Python backend. My main criteria here were to have super-fast deployment, super simple configuration when running in a container, and the ability to handle a big load.

It is like comparing Apples to Oranges.

ReSharper is a popular developer productivity extension for Microsoft Visual Studio. It provides a wide range of features to help developers write better code, including code analysis, refactoring, navigation, and code generation. It also supports a variety of programming languages, including C#, VB.NET, XAML, and JavaScript. ReSharper is developed by JetBrains, a company that specializes in creating development tools.

SonarQube is an open-source platform for continuous inspection of code quality. It provides an overview of an application's technical debt, and gives developers actionable issues, and measures of code maintainability, test coverage and duplication. It supports wide v programming languages, including Java, C#, JavaScript, and PHP. SonarQube can be integrated with popular build and development tools like Jenkins, Maven, and Visual Studio. It also provides a web-based interface for browsing and analyzing code quality metrics and can be used for static and dynamic code analysis. It also has the capability of identifying and alerting on vulnerabilities and bugs.

From the coding point of view, probably the obvious answer would be Locust, but let's look into this thing even further and why JMeter is the way to go for me.

Same as Locust, JMeter is pretty well documented, but the main distinct feature it has - is the UI - you can design your tests visually and on pretty much any platform that runs Java. Even if you have never touched JMeter before, you can still figure out the way through by trial and error or by taking one of the Udemy classes, one of them is "JMeter 2021 | Short Course | Step by Step for Beginners " (https://www.udemy.com/share/105rYY3@-BaI3rp12FLFWGfZfSNeZP4IhadMPEqCI7tRfw7RHcC0AI4DHfzaggmBQnpMvBXi/) I found it pretty okay as a starting point.

JMeter allows scripting; one of them is BeanShell, lightweight scripting for Java. More, you can add OS-level processes to be part of your testing - I, for example, run Hurl tests first (https://hurl.dev/) to probe my API endpoints, and on their completion, run the rest of the tests scripted in JMeter.

Then, maybe you want to run your tests from multiple clouds and get the real picture of the performance - there BlazeMeter for that (https://www.blazemeter.com/), - a continuous testing platform where you can upload your JMeter tests as is. More, they have a plugin for Chrome-based browsers that allows you to 'record' your test script while browsing some web app or website and then export that recording into JMeter.

Hurl, until now, was my favorite tool for API testing, but there is a new 'toy' on the market, httpx (https://httpx.sh/); if you are already familiar with JetBrains HTTTP Client syntax, you can just hop on writing tests in familiar syntax. Httpx is a total badass when it comes to writing 'multi-model' tests, like when you need to do something with RESt API and then reuse this data in PUB/SUB or even run something n SSH.

ArangoDB allows application developers to write their data access and domain logic as microservices running directly within the database with native access to in-memory data. The Foxx microservice framework makes it easy to extend ArangoDB’s REST API with custom HTTP endpoints using modern JavaScript running on the same V8 engine you know from Node.js and the Google Chrome web browser.

Unlike traditional approaches to storing logic in the database (like stored procedures), these microservices can be written as regular structured JavaScript applications that can be easily distributed and version controlled. Depending on your project’s needs, Foxx can be used to build anything from optimized REST endpoints performing complex data access to entire standalone applications running directly inside the database.

https://github.com/skitsanos/foxx-builder

Hi,

I have been doing NoSQL for a long while, even before it was a thing. Berkely DB XML, Sedna, IBM DB/2 with their XML/Xquery types, even own XML-over-FS. Then there was CouchDB, known to some as IBM Cloudant - the only IDE ever made for it was my work.

Back in time, I used to write those 3-tier apps where I always needed to have a backend, and most of my backends were on Node.js; what got changed with ArangoDB’s arrival was - that I could get rid of one element; I had no need anymore for the database backend. Imagine you have a database with a V8 JavaScript engine sitting on top of it. So you continue developing your code in Node.js but deploy it directly to the database without needing Fastify, Express, Nest, or whatever.

The query language in ArangoDB - AQL (https://www.arangodb.com/docs/stable/aql/) will bring you some pleasure, especially if you come from the MongoDB world. For me, it was somewhat even easier to jump in because I had a background in XQuery; SQL, on the other hand, was always an ugly duck for me.

Sometimes (or most of the time), it is not the best thing to follow mainstream trends and hypes; it is something you will have to decide for yourself, do you want to be ‘just another developer’ or a developer that creates products and stands out. Aligning yourself with skillsets from freelancing sites is not the best way of advancing your career; you need something that will stand you out.

ArnagoDB solves you, besides the tech stack, headaches like learning curve, maintenance, scalability, and simplicity in growing your development team and making your backend(less) more complex.

I can reveal you our secret weapon for 95% of apps: (Netlify + OpenResty + ArangoDB) - for the backend, (React + UmiJs + Ant.Design + ahooks) for the frontend. I’ve created and open-sourced Foxx-Builder as a tool to build APIs even faster way than ArangoDB provides by itself, have a look at https://github.com/skitsanos/foxx-builder I have tried to document it in the most detailed way possible.

And here are some links for you

• https://www.arangodb.com/tutorials/mongodb-to-arangodb-tutorial/ - Modelling data in ArangoDB vs. MongoDB
• https://www.arangodb.com/solutions/comparisons/arangodb-vs-mongodb/ - What you can't do with MongoDB
• https://www.udemy.com/course/getting-started-with-arangodb/ - Udemy: Getting Started with ArangoDB
• https://www.youtube.com/watch?v=fIWX3s9B-f0&list=PL0tn-TSss6NV45d1HnLA57VJFH6h1SeH7 - Intro to the Foxx Microservices Framework

To be honest, it is more like 'apples vs oranges', but since it is about pipelines, I think I can bring some light to it. I do have a background with CircleCI, Jenkins, and GitHub Actions (yes, you can use that one too to do your transcoding and so on).

I had no prior experience with ConcourseCI until I read your post, but because I m very familiar with what you are trying to do (years as API Support Lead for vzaar.com) it was pretty simple for me to figure out the flow for ConcourseCI. Setting it in a docker is literally a few mins deal, just documentation is not exactly user-friendly.

So yes, you can use ConcourseCI, you can also add MinIO (https://min.io/) to set up S3 storage, - if you want to run it as a cluster, you need at least 4 computing instances or VPSs.

I have a background in ChatOps on Slack and Mattermost; one of my clients had a few concerns about how things were done on Slack, so I needed to find an alternative to migrate into. After some evaluations and trials, we agreed on Mattermost.

We had many integrations mainly driven by inbound and outbound webhooks, besides those standard ones like GitHub integrations and so on.

Also, it was crucial to keep the same look and feel so people could use their Slack themes as is.

Because data ownership especially when it comes to files sent within chat sessions is a big deal, I've made the following config:

⇢ Mattermost runs on computing instances on Oracle Cloud (you can run one or more instances and put the load balancer in front of your backend sets, otherwise you can go with OpenResty/nginx)

⇢ Chat data is stored in Oracle Cloud's MySQL Database

⇢ Files were stored on S3-compatible storage implemented using MinIO (https://min.io/), you need a minimum of 4 computing instances to implement a cluster.

⇢ OpenResty that I used for upstream load balancing was also responsible for handling webhooks and bots, written in Lua (OpenResty is nginx+LuJIT)

Mattermost is extremely well documented on its own website and on IBM ChatOps documentation, so installing and upgrading/updating it is a very smooth experience.