Instant live customer conversations! Empower your inside sales team by automating the hardest parts of outbound calling. Orum leverages AI to detect voicemails, filter out bad numbers, and navigate phone directories to get your reps into live conversations quickly. Orum allows for calling multiple numbers in parallel, automatically marking dispositions and call outcomes in your CRM and most importantly, helping you speak with more of your prospective clients. We plug right in with Salesforce, Outreach and SalesLoft. With Orum, there's no more waiting for Voicemails, manual dialing or fumbling for your account research. We bring all the research you need in front of your reps and connect you with your target clients instantly!

Orum

orum

Onvif (stands for: O pen N etwork V ideo I nterface F orum) is a non-profit with the goal of facilitating the development and use of a global open standard for the interface of physical IP-based security products — Wikipedia Being able to control your house, open doors, view in real time your living room, control the lights is a childhood dream! I was really delighted to develop an app and a dependency to ease the development of ONVIF Android apps. ONVIF goal is to standardise how IP products (video surveillance cameras, alarms, doors, audio recorders…) communicate with each others. They created some specifications manufacturers have to conform to to be compliant with ONVIF. The goal behind these specifications is to standardise how to connect to these products, for instance if you develop an app for streaming video from an ONVIF camera, it should work with every ONVIF camera. Try it! If you just want to try the demo project, you can download the . Open it with Android Studio and run it, that’s it! sample project on Github You will be able to login on ONVIF camera and view its live stream: every Streaming from an ONVIF cameraHow to connect to a camera and visualise its live stream on Android? 👨🏽‍💻 Create a new project on Android Studio Add implementation and implementation to your (Module: app) com.rvirin.onvif:onvifcamera:1.1.6 com.squareup.okhttp3:okhttp:3.10.0 build.gradle Once it’s done, you can add the following code to connect to the camera and retrieve its information: (), OnvifListener { { .onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        currentDevice = OnvifDevice( , , )
        currentDevice.listener = currentDevice.getServices()
    } {
        Log.d( , )
        Log.d( , : class MainActivity AppCompatActivity override fun onCreate (savedInstanceState: ?) Bundle super "IP_ADDRESS:PORT" "login" "pwd" this override fun requestPerformed (response: ) OnvifResponse "ONVIF" "Request performed." ${response.request.type} "ONVIF" "Succeeded: , 
		  message: ”)
	
	if (response.request.type == GetServices) {
            currentDevice.getDeviceInformation()
        }
    }    
} ${response.success} ${response.parsingUIMessage} To instantiate an ONVIF camera, we use the class , this class takes an which defines the method. This method is called once the camera returns a call we made (getDeviceInformation, getProfiles, getStreamUri). OnvifDevice OnvifListener requestPerformed() Calling before getting the information is not mandatory but strongly recommended. It retrieves the different paths depending on the web service you’re calling, from one camera to another it can change. For instance command will have this path on a Dahua camera whereas it will be on a Uniview camera. Note: getServices getProfiles /onvif/media2_service /onvif/media2 If you implement new web services call in your app, you need to parse their path in this call. To be able to see the live stream of the camera we need to retrieve the different profiles (media profiles, with different configurations available) from the camera, select the one we want to play and retrieve the corresponding stream URI. Here is how we retrieve the profiles and the stream URI: {
        Log.d( , )
        Log.d( , ONVIF Stream URI retrieved: ${currentDevice.rtspURI} override fun requestPerformed (response: ) OnvifResponse "ONVIF" "Request performed." ${response.request.type} "ONVIF" "Succeeded: , 
		  message: ”)
        if (response.request.type == GetServices) {
            currentDevice.getDeviceInformation()
		
        } else if (response.request.type == GetDeviceInformation) {
            currentDevice.getProfiles()
        } else if (response.request.type == GetProfiles) {
            currentDevice.getStreamURI()
        } else if (response.request.type == GetStreamURI) {
            Log.d(" ${response.success} ${response.parsingUIMessage} ", " ")
        }
    }
} Depending on your camera, your URI will look like this one: etc… rtsp://IP_ADDRESS:PORT/cam/realmonitor?channel=1 The URI does not follow the http protocol, but the rtsp protocol, which is normal because (Real Time Streaming Protocol) is aiming to make streaming simpler. The problem is, doesn’t handle RTSP well (it can work but not with every codec, which is a problem to stream from an ONVIF camera). Fortunately, comes to the rescue! RTSP VideoView VLC How to read a RTSP stream on Android? 🎥 Add these lines to your build.gradle: { {
    maven { url }
  }
} { } allprojects repositories 'https://jitpack.io' dependencies compile 'com.github.pedroSG94.vlc-example-streamplayer:pedrovlc:2.5.14' Here is how you play the video with once you have the rtsp URI: libVLC (), VlcListener { vlcVideoLibrary: VlcVideoLibrary? = { .onCreate(savedInstanceState)
        setContentView(R.layout.activity_stream) surfaceView = findViewById<SurfaceView>(R.id.surfaceView)
        vlcVideoLibrary = VlcVideoLibrary( , , surfaceView)
	  vlcVideoLibrary?.play(url)

    } {
        Toast.makeText( , , Toast.LENGTH_SHORT).show()
    } {
        Toast.makeText( , , Toast.LENGTH_SHORT).show()
        vlcVideoLibrary?.stop()
    }
} : class StreamActivity AppCompatActivity private var null override fun onCreate (savedInstanceState: ?) Bundle super val this this override fun onComplete () this "Playing" override fun onError () this "Error, make sure your endpoint is correct" implements two methods ( , and ). They are called by to tell us if the video loads without any problem. VLCListener onComplete() onError() VlcVideoLibrary You can also insert the login and password in the rtsp uri like this: etc… If you use the dependency, the URI saved in contains the login and password. Tip: rtsp:// login:password @IP_ADDRESS:PORT/cam/realmonitor?channel=1 ONVIFCamera OnvifDevice.rtspUri If you want to learn how to create the same project on , you can read . iOS this article Creating an ONVIF library was a exciting opportunity, as you can see in my , I really enjoy having an interaction between my apps and hardware devices, whether it’s a printer for iPhone, a camera, or even a door! I’m really looking forward to test new ONVIF devices and develop apps that can be useful for everyone that has ONVIF devices. previous posts The code of this project is open source, you can download it on . Github If you have any question, I’ll be happy to read them in the comments!

Live stream an ONVIF Camera on your Android app! 📱

We all need a reminder from time to time; Speak clearly and slowly, Focus on three people in the audience , Put one foot in front, so you don’t rock, Use hand gestures to better engage your listeners , Use short slides and explain them (people either listen to you or read your slides), Don’t say ‘am’ or ‘um’ when thinking what to say next. Finish on point that can be pondered by your listeners, pause, and formulate your next sentence. Confidence is key, believe in your content and you will feel confident. is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising & sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

6 Incredibly Simple But Vital Public Speaking Tips

ORM, short for Online Reputation Management, is a common term in Web 2. However, it is relatively unheard of in Web 3. In the world of Web 3, hackers are constantly seeking ways to exploit vulnerabilities and gain access to valuable crypto assets. Malicious actors will go to great lengths to achieve their goals, from impersonating celebrities to generating fraudulent user content directed to phishing websites. This is why Online Reputation Management (ORM) is critical for Web 3 communities. By proactively monitoring and managing your community's online reputation, you can safeguard your brand and protect your users from potential threats. How does ORM work in Web 3? Crypto is fundamentally community-driven, meaning it is user-generated content-driven. We rely heavily on online social cues and metrics from common users rather than influencers, as in the Web 2.0 world. Why take it from me? I work as a verifier for , a project born out of , a venture builder founded by Temasek. I provide expert opinions and analysis on the authenticity of NFT projects, having worked close to 20 projects ranking them on their use case, deliverables & roadmap. authentickator M enyala During my time in web 2.0, I’m a digital asset acquisition strategist, specialising in . I acquired over 100 domains, websites, and social media accounts through auctions, aftermarkets, and private dealings since 2014. My years of experience in due diligence have helped me develop a keen sense for vetting project authenticity and identifying potential shortcomings that will affect business valuation & security risks. growth hacking Example 1: Lacoste’s NFT project, UNDW3: The Emerge, used to not have an official twitter account for their NFT project. This was my review with authentick regarding the project. https://twitter.com/undw3_lacoste/status/1666444466880651265?embedable=true They recently setup their official, verified twitter account after numerous scam attempts mentioned in their discord chat. Example 2: Sushiswap’s acquisition of sushi.com ”SushiSwap’s online presence is notoriously scattered, including domains like “ ” and “ ” as mentioned in cointelegraph. sushiswap.fi sushiswapclassic.org https://cointelegraph.com/news/with-rebrand-on-the-horizon-sushiswap-receives-sushi-com-domain-name-gift?embedable=true After their acquisition of sushi.com, they are much less vulnerable to domain-name based attacks. Examples of ORM Mistakes, Risks & Methods There are several ways to improve online reputation management (ORM) to prevent breaches or malicious damage. Here are some problems and consequences for projects that don't put enough care into ORM, as well as the methods used to breach projects without proper ORM. Founder have limited social presence, opens up the project to impersonation: It is important for founders to have a strong social media presence to establish their identity and authority within the Web 3 community. This helps prevent bad actors from impersonating them and misleading the community. Additionally, a strong social media presence can help build trust and credibility with potential investors and partners. Scammers flooding hashtag with fraudulent news, when the project doesn’t use their cashtag often: This is a common tactic used by scammers to mislead the community and promote fraudulent projects. It is important for projects to regularly use their official cashtag and monitor social media channels for fraudulent activity. By doing so, they can quickly identify and address scams, protecting the community from potential losses. Inactive community, allowing vulnerability shillers to redirect community to other projects: An inactive community can leave a project vulnerable to shilling and redirecting tactics used by bad actors. It is important for projects to actively engage with their community, provide regular updates, and encourage participation. By doing so, they can build a strong community that is resistant to outside manipulation. Buying the cheapest domain name extension available, allowing bad actors to create clones using similar domain names, leading to a phishing site: This is a common tactic used by scammers to mislead users and steal their credentials or assets. It is important for projects to secure their brand name and domain names in all TLDs, and to monitor search engine results for any fraudulent activity. By doing so, they can quickly identify and address scams, protecting the community from potential losses. Outranking the official brand on Twitter/Instagram leading to a phishing website: This is another tactic used by scammers to mislead users and steal their credentials or assets. It is important for projects to regularly monitor their social media channels for fraudulent activity, and to take action against any accounts that are impersonating or misleading users. By doing so, they can protect the community from potential losses and maintain their reputation. Pretending to hire for personal information as a social engineering method to breach wallet: This is a common tactic used by scammers to gain access to personal information or assets. It is important for users to be cautious of unsolicited job offers or requests for personal information, and to verify the legitimacy of any requests before responding. By doing so, they can protect themselves from potential scams and maintain their security. Using a public facing email to signup for crypto wallet accounts, social media accounts & personal details & reusing passwords that has been leaked on public domain Conclusion In the world of Web 3, user-generated content (UGC) is crucial for crypto communities as they are fundamentally community-driven. As a result, having the right and guidelines for your project is essential to building a strong, damage-proof project. UGC Creators Setting up gamified community incentives has always been a popular choice among NFT and crypto projects. However, relying solely on monetary rewards for community engagement is not a sustainable long-term strategy. Online reputation management is not just about presenting the positive side of the project, but conveying the right message to your target audience and retaining them as loyal community members. Building a proper Web 3 community requires a multifaceted approach that includes not only gamification, but also a strong focus on community trust and onboarding the right ambassadors to ensure the project's survival during bear markets. After all, most progress is made during bear markets, not bull markets.

ORM for Web 3 Communities: Protecting Your Reputation and Security

ORM para comunidades Web 3: protección de su reputación y seguridad

ORM pour les communautés Web 3 : protéger votre réputation et votre sécurité

वेब 3 समुदायों के लिए ओआरएम: आपकी प्रतिष्ठा और सुरक्षा की रक्षा करना

Web 3 コミュニティの ORM: 評判とセキュリティの保護

ORM para comunidades Web 3: protegendo sua reputação e segurança

ORM dành cho cộng đồng Web 3: Bảo vệ danh tiếng và bảo mật của bạn

Web 3 社区的 ORM：保护您的声誉和安全

After a decade of software engineering work (professional and personal), particularly in front-end development, I’ve crafted something I’m proud of. In this article, I’ll walk you through my ideal tech stack and the intricate decisions that shaped MeetMomentum. Join me as we explore the nuts and bolts of building a tool designed to revolutionize how we manage time across global time zones. Project Overview In today’s connected world, tools to track global timezones aren’t just a necessity; they’re a lifeline for professionals and travellers alike. Unfortunately, most calendar solutions do not offer effective multi-time zone support when scheduling and I personally faced many struggles because of this. That’s how I started to come up with the MeetMomentum vision. I wanted to build something that truly accounts for infinite time zones, visually and intuitively. I also wanted to make sure it integrates with my existing calendar, so I don't have to look at multiple screens just to book a single meeting. Design The design was one of the biggest challenges. There is a good reason why most applications don't support more than two time zones. It is not possible to fit all that information, in a digestible manner. At least not with the existing approach. The existing approach is having all five days aligned and invitees’ agendas overlapping. Instead, we flipped the calendar view on it’s side, presenting each invitee's schedule on their own horizontal line, offset by their unique time zone. To navigate the calender users can simply swipe or scroll horizontally, and by maintaining the offset, we ensure perfect time zone alignment, in a very clean manner. This is the core of our innovation, however, it came with a surprising set of technical challenges! Have a play on the final outcome here: https://www.meetmomentum.tech/ Technical Stack Before diving any deeper, let's start by painting the landscape. Embarking on any software project requires a solid foundation, and the technical stack is where it all begins. In the development of MeetMomentum, choosing the right technologies was crucial to ensure flexibility, efficiency, and scalability. Programming Languages Used: TypeScript/JavaScript


CSS


Markdown/MDX for the blog Frameworks and Libraries: We used pure tailwind for styling, with no extra component libraries, outside a few specific cases where we have utilized Headless UI. We used Framer Motion for more custom animations. Drizzle as a lightweight ORM for composing typesafe queries and managing schema migrations. TRPC for simple server-client connectivity. Zod for validation of data inputs. react-hook-form for user input with its great integration with zod. Tools and Development Environment: Currently, we’re just using npm but might lean into pnpm. We use prettier for formatting. Eslint with various plugins for React, typescript, etc. in order to catch simple issues. Nix is used to provide dependencies outside of node_modules. Stripe dev cli. Architecture Overview: The architecture leans serverless. Being on Vercel, we leverage functions for our serverside compute. As we use supabase, we can also utilize PostgREST and Row Level Security (RLS) to directly and securely access data in the database. And being React on NextJS we can lean into SSG and client-side processing. Database Management: As mentioned above the database is Postgres on Supabase with RLS and PostgREST being key plugins. Server Infrastructure: Hosting on Vercel. Design Patterns: Design patterns such as MVC don’t really map onto React very well. The general approach is to keep the state as close to where it’s used so updates are only triggered for relevant areas of the page. Optimizations can be made in cases where updates are triggered but inputs have not meaningfully changed. State that is important across the application is handled via Zustand. In some cases, components are split into the part that handles and provides state, and the part that is visual with elements and styles. This can help to build out the component’s style and debug without needing to replicate the exact state in a more real-world scenario. However, sometimes it’s easier to have a combined component just to get something finished. Continuous Integration/Continuous Deployment (CI/CD): Vercel integration with GH runs ‘build’ and we run most of our linting and tests as part of that build. With a focus on SSG and client-side processing server-side compute is reduced. The vast majority of server-side compute is tied to accounts that can be managed carefully, and Vercel has capabilities to defend against abuse such as a DDoS attack. So, in general, the platform should scale very well without much intervention. There is room to improve some actions so we can leverage caching more or consolidate some requests but these are not of high concern until we reach much larger scales and can be worked on in the background. Major Challenges As mentioned before, one of the biggest challenges was building the horizontal scroll for the scheduling offsets. This would technically be called an ‘infinite horizontal scroll sync,’ and it seems like we were the first use case for it! The reason why it was so challenging was managing the browsers’ performance while triggering many browser events due to scrolling and lining up timezones accounting for their offsets. Keep in mind that each horizontal line had to be kept independent, as the user could at any point change the order with our ‘drag and drop’ features. And to make things harder for ourselves, we also had multiple time pickers that worked by aligning the exact position of the scroller. We tried multiple approaches, like having individual hour elements, and had to restart on at least four different occasions. But the result was worth it! Another major challenge was transitioning from the public scheduler to a personalized one, that integrates with your agenda. This time, the problem lies in trying to fit the agenda-related information into a small horizontal view. To get to our fleshed-out product, we had to undertake a lot of iteration, trial and error, and of course, user feedback! We also faced multiple technical challenges, such as integrating with the Google Calendar APIs, getting permission to handle user’s data, and so on. Outcomes User feedback for MeetMomentum.tech has been very positive. Users enjoy the convenience and creativity aspects, but we are still very early in our journey. Stay tuned as we evolve, enhancing MeetMomentum.tech to better serve you and the global community; one update at a time. After a decade of software engineering work (professional and personal), particularly in front-end development, I’ve crafted something I’m proud of. In this article, I’ll walk you through my ideal tech stack and the intricate decisions that shaped MeetMomentum. Join me as we explore the nuts and bolts of building a tool designed to revolutionize how we manage time across global time zones. Project Overview In today’s connected world, tools to track global timezones aren’t just a necessity; they’re a lifeline for professionals and travellers alike. Unfortunately, most calendar solutions do not offer effective multi-time zone support when scheduling and I personally faced many struggles because of this. That’s how I started to come up with the MeetMomentum vision. I wanted to build something that truly accounts for infinite time zones, visually and intuitively. I also wanted to make sure it integrates with my existing calendar, so I don't have to look at multiple screens just to book a single meeting. Design The design was one of the biggest challenges. There is a good reason why most applications don't support more than two time zones. It is not possible to fit all that information, in a digestible manner. At least not with the existing approach. The existing approach is having all five days aligned and invitees’ agendas overlapping. Instead, we flipped the calendar view on it’s side, presenting each invitee's schedule on their own horizontal line, offset by their unique time zone. To navigate the calender users can simply swipe or scroll horizontally, and by maintaining the offset, we ensure perfect time zone alignment, in a very clean manner. This is the core of our innovation, however, it came with a surprising set of technical challenges! Have a play on the final outcome here: https://www.meetmomentum.tech/ https://www.meetmomentum.tech/ Technical Stack Before diving any deeper, let's start by painting the landscape. Embarking on any software project requires a solid foundation, and the technical stack is where it all begins. In the development of MeetMomentum, choosing the right technologies was crucial to ensure flexibility, efficiency, and scalability. Programming Languages Used: Programming Languages Used: TypeScript/JavaScript CSS Markdown/MDX for the blog TypeScript/JavaScript TypeScript/JavaScript CSS CSS Markdown/MDX for the blog Markdown/MDX for the blog Frameworks and Libraries: Frameworks and Libraries: We used pure tailwind for styling, with no extra component libraries, outside a few specific cases where we have utilized Headless UI. We used pure tailwind for styling, with no extra component libraries, outside a few specific cases where we have utilized Headless UI. We used Framer Motion for more custom animations. We used Framer Motion for more custom animations. Drizzle as a lightweight ORM for composing typesafe queries and managing schema migrations. Drizzle as a lightweight ORM for composing typesafe queries and managing schema migrations. TRPC for simple server-client connectivity. TRPC for simple server-client connectivity. Zod for validation of data inputs. Zod for validation of data inputs. react-hook-form for user input with its great integration with zod. react-hook-form for user input with its great integration with zod. react-hook-form for user input with its great integration with zod. Tools and Development Environment: Tools and Development Environment: Currently, we’re just using npm but might lean into pnpm. Currently, we’re just using npm but might lean into pnpm. We use prettier for formatting. We use prettier for formatting. Eslint with various plugins for React, typescript, etc. in order to catch simple issues. Eslint with various plugins for React, typescript, etc. in order to catch simple issues. Nix is used to provide dependencies outside of node_modules. Nix is used to provide dependencies outside of node_modules. Stripe dev cli. Stripe dev cli. Architecture Overview: Architecture Overview: The architecture leans serverless. Being on Vercel, we leverage functions for our serverside compute. As we use supabase, we can also utilize PostgREST and Row Level Security (RLS) to directly and securely access data in the database. And being React on NextJS we can lean into SSG and client-side processing. Database Management: Database Management: As mentioned above the database is Postgres on Supabase with RLS and PostgREST being key plugins. Server Infrastructure: Server Infrastructure: Hosting on Vercel. Design Patterns: Design Patterns: Design patterns such as MVC don’t really map onto React very well. The general approach is to keep the state as close to where it’s used so updates are only triggered for relevant areas of the page. Optimizations can be made in cases where updates are triggered but inputs have not meaningfully changed. State that is important across the application is handled via Zustand. In some cases, components are split into the part that handles and provides state, and the part that is visual with elements and styles. This can help to build out the component’s style and debug without needing to replicate the exact state in a more real-world scenario. However, sometimes it’s easier to have a combined component just to get something finished. Continuous Integration/Continuous Deployment (CI/CD): Continuous Integration/Continuous Deployment (CI/CD): Vercel integration with GH runs ‘build’ and we run most of our linting and tests as part of that build. With a focus on SSG and client-side processing server-side compute is reduced. The vast majority of server-side compute is tied to accounts that can be managed carefully, and Vercel has capabilities to defend against abuse such as a DDoS attack. So, in general, the platform should scale very well without much intervention. There is room to improve some actions so we can leverage caching more or consolidate some requests but these are not of high concern until we reach much larger scales and can be worked on in the background. Major Challenges As mentioned before, one of the biggest challenges was building the horizontal scroll for the scheduling offsets. This would technically be called an ‘infinite horizontal scroll sync,’ and it seems like we were the first use case for it! The reason why it was so challenging was managing the browsers’ performance while triggering many browser events due to scrolling and lining up timezones accounting for their offsets. Keep in mind that each horizontal line had to be kept independent, as the user could at any point change the order with our ‘drag and drop’ features. And to make things harder for ourselves, we also had multiple time pickers that worked by aligning the exact position of the scroller. We tried multiple approaches, like having individual hour elements, and had to restart on at least four different occasions. But the result was worth it! Another major challenge was transitioning from the public scheduler to a personalized one, that integrates with your agenda. This time, the problem lies in trying to fit the agenda-related information into a small horizontal view. To get to our fleshed-out product, we had to undertake a lot of iteration, trial and error, and of course, user feedback! We also faced multiple technical challenges, such as integrating with the Google Calendar APIs, getting permission to handle user’s data, and so on. Outcomes User feedback for MeetMomentum.tech has been very positive. Users enjoy the convenience and creativity aspects, but we are still very early in our journey. Stay tuned as we evolve, enhancing MeetMomentum.tech to better serve you and the global community; one update at a time.

How I Built MeetMomentum: Applying 10 Years of React Experience

Building a CRUD App with Node.js, PostgreSQL, and Prisma

Q: What do a revolutionary from the 1800s, a supercomputer from the 1980s, and a tech start-up which supports decentralisation have in common? A: They’re all fictional. 🤣 Hilarious, right? Introducing the Luddites Let’s tie these things together. First of all, the revolutionary above refers to the folkloric figure of Ned Ludd, also known variously as General, Captain, and King Ludd. Whether there was ever a real Ned Ludd is very much up for debate. Sadly, since the Luddites were pretty much wiped out a couple of centuries ago by the combination of sending the military after them and executing them when captured (they threatened the almighty profit margin after all), we’re not likely to get an answer any time soon. What’s important for this article is that Ned Ludd was an idea. He was a mythical figurehead of a decentralised movement working to protect the livelihood of the individual worker, safeguarding their autonomy in the face of capitalist mechanical automation which worked to reduce them (or rather their cheaper, unskilled replacements) to cogs in a commercial machine. The Luddites are far from the first decentralised movement, and definitely not the last. They were unique, to my knowledge, in being the first to assemble a decentralised movement to oppose centralisation and concentration of power in the hands of a few. Those few being the capitalists who purchased the machines with the aim of exploiting their workforce by removing the need for expensive expertise. The Luddites were presented then, and are again now, as straightforward anti-progress revolutionaries. Even now the name is used as an insult, suggesting someone obstructs progress for the sake of obstruction. Ironically, those at the cutting edge of technologies designed to protect individual autonomy and identity have more in common with the Luddites than they do with most of the high-tech start-ups who claim to be fighting their corners. And the Supercomputer? In 1983 a film came out which became a cornerstone of hacker culture. No, not , I’m talking about the rightly-famous . Aside from being an innovative film, provides a brilliant illustration both of the danger of centralising power and authority, and of placing too much trust in technological infallibility. Hackers Wargames Wargames At the centre of the film is a supercomputer, Joshua (or more formally the WOPR), which controls the entire US nuclear arsenal and defensive systems. Even if you haven’t seen it, you can probably predict the rest of the film just from that. The centralisation piece is particularly striking when you know three names which deserve to go down in history (and likely others we don’t know): Stanislav Petrov, Vasily Arkhipov, and Sir David Ormsby-Gore. Their stories are worth looking up, but for this article what’s important to know is that it was their individual decision-making, their exercise of their autonomy, that means we’re not living in a nuclear hellscape today. As Joshua famously writes in , when there is only mutually assured destruction the only winning move is not to play. Wargames Obviously this lesson cannot be ascribed to our modern world, where we are completely dependent on massive interconnected systems designed to squeeze all the joy and freedom out of life and turn them into profitable numbers while having us make ‘the right’ decisions (i.e. buying the things advertised to us). Tech Start-Ups Are Fine Though, Right? And that brings us to the modern tech start-up, especially those that preach decentralisation and autonomy. Some, I’m sure, are sincere - it’s a statistical impossibility that all of them are presenting a smokescreen, but it’s definitely a minority. There’s a whole rainbow of -washings (green, pink, etc.) that companies use to publicly show off their credentials, whether social, environmental, diversity, or otherwise, while carrying on as normal behind the scenes, but I’m unsure what colour would apply to autonomy. VC-backed start-ups are funded by investment. Investors are looking for a return on their investment - usually by selling the company to bigger investors later on. Even if the first investors strongly believe in the ideals of the company rather than just the opportunity for profit, success and a sale dilutes everything further and further from those initial aims. Driving and supporting autonomy and decentralisation of power inevitably builds systems where it is harder for a single entity to extract value in the form of profit for themselves. Decentralised systems are resilient, not robust. They’re sustainable, not efficient. They tend towards value-sharing, not profit-making. This is a problem if the key incentives that drive an organisation are monetary returns on investments. What’s the Answer? Is there anything that can be done? Well, to a degree. The system is clearly built in such a way that gathering the resources to change it requires a level of investment which makes it hard to then change it without causing yourself damage. Taking part in these larger systems constrains our choices and autonomy, while opting out of them leaves us with ideological movements. Movements which are often unable to take effective actions, and easy for coordinated efforts to subvert for their own ends. At some point there may be enough smaller entities which aren’t profit-driven pulling in the same direction to make a difference, but until then all we can do is just not play the game. Instead of pursuing the big pay cheques of major tech companies, look to smaller organisations with different motivations. A question I was always told to ask when going to interviews was “why are you in business?” If the answer was “to make money”, it was not a sustainable place to work. For an organisation money should be a means to an end. Treating it as an end in itself is just chasing after a high score that means nothing outside the arcade (80s reference just to tie back to there). Wargames Take a lesson from the Luddites. Yes, they failed. Yes, they were utterly crushed by a system that turned people into nothing more than components in a money-making machine with no autonomy, no power, and no identity beyond ‘worker’. Failure doesn’t mean they were wrong. This article should not be taken as an incentive to or an endorsement of taking direct destructive action against datacentres, infrastructure, technology companies or similar. The author fully endorses the ideals of the Luddites, not their methods, or at least not the methods that will lead to similar reactions to those they faced.

Luddites, WarGames, and the Lost Battle for Autonomy

How to Master .NET 8 Web API: From Setup to Security - The Best 50 Tips

কিভাবে .NET 8 ওয়েব এপিআই আয়ত্ত করবেন: সেটআপ থেকে নিরাপত্তা - সেরা 50 টি টিপস

.NET 8 Web API meistern: Von der Einrichtung bis zur Sicherheit – Die 50 besten Tipps

Cómo dominar la API web .NET 8: de la configuración a la seguridad: los 50 mejores consejos

Comment maîtriser l'API Web .NET 8 : de la configuration à la sécurité - Les 50 meilleurs conseils

.NET 8 वेब एपीआई में महारत कैसे हासिल करें: सेटअप से सुरक्षा तक - सर्वोत्तम 50 युक्तियाँ

.NET 8 Web API をマスターする方法: セットアップからセキュリティまで - ベスト 50 のヒント

.NET 8 Web API를 마스터하는 방법: 설정부터 보안까지 - 최고의 50가지 팁

Como dominar a API da Web .NET 8: da configuração à segurança - as 50 melhores dicas

Как освоить веб-API .NET 8: от настройки до безопасности — 50 лучших советов

.NET 8 Web API'sinde Uzmanlaşma: Kurulumdan Güvenliğe - En İyi 50 İpucu

Cách làm chủ API Web .NET 8: Từ thiết lập đến bảo mật - 50 mẹo hay nhất

如何掌握 .NET 8 Web API：从设置到安全 - 50 个最佳技巧

Navigating the SEO landscape can be complex, but simplifies this with clear-cut strategies and measurable results. Through the insight of their Founder, Scott Keever, this agency has made a mark with targeted SEO strategies. Our deep dive into their approach will show you why and how they make a real difference to businesses online. Keever SEO Keever SEO: The Award-Winning Agency Keever SEO is a search engine optimization company providing data-driven search engine marketing results. Keever SEO is an award-winning SEO agency. Established in 2015 by entrepreneur, internationally recognized SEO expert, and online reputation management mastermind Scott Keever, Keever SEO is a multi-award-winning digital marketing agency for businesses of all sizes. With a specialization in SEO, Local SEO, and online reputation management, Keever SEO helps clients gain more targeted traffic and revenue through data-driven SEO strategies. Keever SEO is one of the fastest-growing digital marketing agencies in the US and has helped hundreds of businesses secure prominent Page 1 rankings on Google. More than a mere search engine optimization company, stands as a beacon of excellence amidst the competitive digital marketing landscape. Founded by the visionary entrepreneur Scott Keever, the agency’s journey is a story of relentless innovation, technical expertise, and groundbreaking achievements in the industry. Keever SEO Awards and Recognition The reputation of Keever SEO as an acclaimed SEO agency resonates in its trophy cabinet, a testament to its digital marketing prowess. The agency’s consistent performance has earned it four UpCity National Excellence Awards and five Top SEO Agencies Awards, a testament to its unwavering commitment to delivering results that matter. Rapid Growth The rise of Keever SEO within the digital marketing realm resembles a meteoric ascension. Recognized as one of the fastest-growing digital marketing agencies in the U.S., Keever SEO owes its rapid growth to its specialized services focusing on SEO, local SEO, and online reputation management, which rapidly spread among clients. Scott Keever: The Visionary Behind Keever SEO is an entrepreneur, internationally recognized SEO expert, online reputation mastermind, and member of the Forbes Agency Council. Scott Keever He is the founder of award-winning digital marketing agencies: Keever SEO, Asap Digital Marketing, and Pool Pros Marketing. Learn more about and his complete bio here. Scott Keever Comprehensive Services for Online Success Going beyond the traditional scope of a search engine optimization company, Keever SEO provides a wide array of digital marketing services designed to cultivate online success. Local SEO With the advent of a hyper-connected world, local businesses require more than mere online presence - they need more targeted traffic to help businesses secure prominent positions in search results, which is exactly what Keever SEO’s Local SEO services provide. Online Reputation Management In a world where a single negative review can tarnish a reputation painstakingly built over the years, online reputation management is critical. Keever SEO understands this all too well and has carved out a niche in providing Online Reputation Management (ORM) services, focusing on high-profile individuals such as celebrities, athletes, and business moguls. Data-Driven Strategies for Maximum Impact Within the sphere of SEO, Keever SEO reigns as the master of data. The agency utilizes sophisticated data analytics to analyze client website traffic patterns, customizing their data-driven SEO strategies for optimal relevance and effectiveness. Proven Track Record One’s track record serves as the finest testament to a company’s expertise, and the record of Keever SEO exemplifies its proficiency in enhancing organic traffic and boosting search engine rankings. Top Talent Keever SEO’s success is not just built on innovative strategies and advanced analytics. It’s also powered by a team of industry experts recognized for their contribution to thought leadership in SEO and digital marketing strategies. Free Consultation: Taking the First Step If you wish to amplify your online presence and harness the power of inventive digital marketing, Keever SEO is at your service in the digital marketing space. Access their website today for a complimentary consultation on web design, paving your first step towards digital marketing triumph on online platforms. Summary In sum, Keever SEO stands as a beacon of innovation and success in the digital marketing landscape. From its award-winning services to its data-driven strategies, the agency is truly revolutionizing the way businesses approach SEO. With a dedicated team of industry experts and a proven track record of success, Keever SEO is the partner you need to succeed in today’s digital era. Frequently Asked Questions What does Keever SEO do? Keever SEO is a search engine optimization company providing data-driven search engine marketing results. Keever SEO is an award-winning SEO agency. Who is the Founder of Keever SEO? Scott Keever is the founder and CEO of Keever SEO. Where is Keever SEO located? Keever SEO has locations across the country including Cincinnati, OH, Tampa, FL, and Miami, FL. How Much Does Keever SEO Cost? Keever SEO offers monthly SEO services starting at $1000 per month. Who is Scott Keever? Scott Keever is an entrepreneur, internationally recognized SEO expert, online reputation mastermind, and member of the Forbes Agency Council. He is the founder of award-winning digital marketing agencies: Keever SEO, ASAP Digital Marketing, and Pool Pros Marketing. What awards has Keever SEO won? Keever SEO has won the Upcity National Excellence Award from 2020-2023 and the Local Excellence Award for its performance in Tampa and Cincinnati from 2020-2023. This showcases the company's consistent excellence in SEO. Follow Keever SEO on Social Media Keever SEO - Facebook Keever SEO - Twitter Keever SEO - Youtube

Keever SEO: Revolutionizing Digital Marketing With Proven SEO Strategies

This post covers what I've learned about Akamai's VPC, how I deployed one with Terraform, and why it's good for security. Recently, I had the pleasure of attending in Oakland, CA. In addition to working the Akamai booth, making new friends, and spreading the good word of cloud computing, my teammate and I were tasked with creating a demo to showcase the new product. DeveloperWeek Talia VPC Background A Virtual Private Cloud (VPC) enables private communication between two cloud compute instances, isolating network traffic from other internet users, thus improving security. So, how did I decide to showcase this? By building a little Pokémon dashboard, of course. I deployed two apps, each consisting of an app server and a database server (four servers total). The first app + database server pair is deployed normally. The second is configured to run within a VPC. Each app’s front end is built with and uses for styling. The server side is powered by (Qwik’s official meta-framework) and runs on hosted on a . The apps also use for process management and as a reverse proxy and SSL provisioner. The data is stored in a database that also runs on a shared Linode VPS. The apps interact with the database using , an Object-Relational Mapper (ORM) for . The entire infrastructure for both apps is managed with using the , which was new to me but made provisioning and destroying infrastructure really fast and easy (once I learned how it all worked). Qwik Tailwind Qwik City Node.js shared Linode VPS PM2 Caddy PostgreSQL Drizzle JavaScript Terraform Terraform Linode provider If you’re interested, you can find all the code here: github.com/AustinGil/linode-vpc-demo Demo As I mentioned above, the demo deploys two identical apps. There isn’t anything remarkably special about it, but here’s a screenshot. (I had to change the Pokémon names for reasons…) There’s nothing special about this tech stack. I chose these tools because I like them, not necessarily because they were the tools for the job. best The interesting part is the infrastructure. When we consider app #1, it’s essentially made up of two servers hosted inside the Akamai cloud, one server for the app and one for the database. When a user loads the app, the app server pulls the data from the database, constructs the HTML, and returns the result to the user. server The problem here is how the database connection is configured. In some cases, you may deploy a database server without knowing the IP addresses of the computers you want to allow access from (like the app server). In these cases, it’s not uncommon to allow any computer with the right credentials to connect to the database. This presents a security vulnerability because it could allow for a bad actor to connect to the database and steal sensitive data. A bad actor would still need the database host, port, username, and password to get access, so it’s not trivial. And as I said, this is not an uncommon practice, but we can do better. If you know the IP address for every computer that needs access, a good solution might be to set up a or . But if your infrastructure is more dynamic, with servers coming up and down, maintaining lists of IP addresses can be cumbersome. And that’s where VPCs shine. You can configure servers to live within a VPC and allow communication to flow freely only between other computers in the network. firewall VLAN That’s how app #2 is set up. Users can connect to the app server, which allows traffic from the public internet but also lives within the VPC. The app server connects to the database, which is also in the VPC, and only allows connections from within the same network. Then, the app server takes the data, builds the HTML, and returns the page to the user. For a normal user, the experience is identical. The browser loads the table with the modified Pokémon data just fine. The VPC doesn’t change anything for normal users. For bad actors, however, the experience is different. Even if they somehow manage to get the database access credentials, they would not be able to connect because of the network isolation from the VPC. Here, the VPC acts as a virtual firewall, ensuring that only devices with the same network are able to access the database. (This concept is sometimes referred to as “segmentation”) Evidence It’s cool to show a demo and talk about the infrastructure with cute diagrams, but I always want to prove, even if just to myself, that things work as expected. So, I thought a good way to test it would be to try connecting directly to both databases using my database client, . DBeaver For database #1, I set up a Postgres connection using the host IP address I got from my Akamai dashboard and the port, username, and password I had set up in my Terraform script. The connection worked as expected. For database #2, all I had to change was the IP address since all the database provisioning was handled by the same script using Terraform. The only difference was that the database server was put inside the same VPC as the app server, and it was configured to only allow connections from any computer within the same network. As expected, I got an error when trying to connect, even though I had all the correct information. The error doesn’t mention anything about the VPC. It just says that my IP address is not in the allowed list in the configuration file. This makes sense. I could explicitly add my home’s IP address and gain access to the database if needed, but that’s beside the point. The key point is that I did not explicitly add IP address to the Postgres allow-list. Yet, the app server was able to connect just fine, and everyone else was blocked, thanks to the VPC. any Code The last thing I’ll touch on is the Terraform code for deploying this application. You can find the whole file here: [github.com/AustinGil/linode-vpc-demo/blob/main/terraform/terraform.tf](https://github.com/AustinGil/linode-vpc-demo/blob/main/terraform/terraform.tf) It’s also worth mentioning that I tried to make this Terraform file reusable for other people (or future me). That required a bit more variable and config setup based around the file: tfvars [github.com/AustinGil/linode-vpc-demo/blob/main/terraform/terraform.tfvars.example](https://github.com/AustinGil/linode-vpc-demo/blob/main/terraform/terraform.tfvars.example) Anyway, I’m just going to highlight the key parts. 1. Configure Terraform Provider First, since I used the , it makes sense to know how to set that up: Linode Terraform provisioner terraform {
  required_providers {
    linode = {
      source = "linode/linode"
      version = "2.13.0"
    }
  }
}

variable "LINODE_TOKEN" {}

provider "linode" {
  token = var.LINODE_TOKEN
} This part sets up the provider as well as a variable, which Terraform will either ask you for or you can provide with the file. tfvars 2. Set Up VPC and VPC Subnet Next, I set up the actual resource along with a resource. This part required a lot of learning on my part. vpc subnet resource "linode_vpc" "vpc" {
  label = "${local.app_name}-vpc"
  region = var.REGION
}
resource "linode_vpc_subnet" "vpc_subnet" {
  vpc_id = linode_vpc.vpc.id
  label = "${local.app_name}-vpc-subnet"
  ipv4 = "${var.VPC_SUBNET_IP}"
} Servers can only be added to VPCs in the same region. At the time of writing, there are thirteen regions where VPCs are supported. For the most up-to-date details, refer to the docs: . linode.com/docs/products/networking/vpc/ I tried deploying my servers to San Francisco and ran into errors several times before realizing that it wasn’t an available region. So I went with Seattle ( ) instead. "us-sea" The subnets were also a learning point for me. As a web application developer, I haven’t had to do much networking, so when I was asked to provide “ ” I had to research. The IPv4 range of this subnet in CIDR format Turns out, (such as a VPC): there are three IPv4 address ranges that are reserved for private networks 10.0.0.0 – 10.255.255.255 172.16.0.0 – 172.31.255.255 192.168.0.0 – 192.168.255.255 You have to choose one of these three options, but you have to use format, which is a way of representing the IP range you want to use. Don’t ask me for more details, because that’s all I know. Akamai has more . I just went with . CIDR documentation around the subnets 10.0.0.0/24 Every server in the network will have an IPv4 address within that range. private 3. Set Up Application Servers For Terraform to deploy my application servers, I used the resource. I also used the resource to create a reusable deployment script for installing and configuring software. It’s like a script that lives in your Akamai cloud dashboard that you can reuse on new servers. linode_instance [stackscript](https://registry.terraform.io/providers/linode/linode/latest/docs/resources/stackscript) Bash I won’t include the code here, but it installs Node.js 20 via NVM, installs PM2, clones my project repo, runs the app, and sets up Caddy. You can view the StackScript contents in the source code, but I want to focus on the Terraform stuff. resource "linode_instance" "application1" {
  depends_on = [
    linode_instance.database1
  ]
  image = "linode/ubuntu20.04"
  type = "g6-nanode-1"
  label = "${local.app_name}-application1"
  group = "${local.app_name}-group"
  region = var.REGION
  authorized_keys = [ linode_sshkey.ssh_key.ssh_key ]

  stackscript_id = linode_stackscript.configure_app_server.id
  stackscript_data = {
    "GIT_REPO" = var.GIT_REPO,
    "START_COMMAND" = var.START_COMMAND,
    "DOMAIN" = var.DOMAIN1,
    "NODE_PORT" = var.NODE_PORT,
    "DB_HOST" = linode_instance.database1.ip_address,
    "DB_PORT" = var.DB_PORT,
    "DB_NAME" = var.DB_NAME,
    "DB_USER" = var.DB_USER,
    "DB_PASS" = var.DB_PASS,
  }
}
resource "linode_instance" "application2" {
  depends_on = [
    linode_instance.database2
  ]
  image = "linode/ubuntu20.04"
  type = "g6-nanode-1"
  label = "${local.app_name}-application2"
  group = "${local.app_name}-group"
  region = var.REGION
  authorized_keys = [ linode_sshkey.ssh_key.ssh_key ]

  stackscript_id = linode_stackscript.configure_app_server.id
  stackscript_data = {
    "GIT_REPO" = var.GIT_REPO,
    "START_COMMAND" = var.START_COMMAND,
    "DOMAIN" = var.DOMAIN2,
    "NODE_PORT" = var.NODE_PORT,
    "DB_HOST" = var.DB_PRIVATE_IP,
    "DB_PORT" = var.DB_PORT,
    "DB_NAME" = var.DB_NAME,
    "DB_USER" = var.DB_USER,
    "DB_PASS" = var.DB_PASS,
  }

  interface {
    purpose = "public"
  }
  interface {
    purpose   = "vpc"
    subnet_id = linode_vpc_subnet.vpc_subnet.id
  }
} Configuring the two resources is almost identical, with only a few significant things to note: Application #2 includes configuration to add it to the VPC. The StackScript needs the IP address for the database. Application #1 uses the public IP address from database #1 ( ). Application #2 uses a variable ( ). This variable will come up later, but it’s the private IP address assigned to database #2, running within the VPC. This can be manually assigned, so I set it to . linode_instance.database1.ip_address var.DB_PRIVATE_IP 10.0.0.3 Also note that they are deployed to the same region as the VPC, for the reasons I mentioned above. 4. Set Up Database Servers The databases are also set up using the and resources. Once again, I’ll skip the StackScript contents, which you can find in the repo. It installs Postgres, sets up the database and credentials, and provides some configuration options. linode_instance linode_stackscript resource "linode_instance" "database1" {
  image = "linode/ubuntu20.04"
  type = "g6-nanode-1"
  label = "${local.app_name}-db1"
  group = "${local.app_name}-group"
  region = var.REGION

  authorized_keys = [ linode_sshkey.ssh_key.ssh_key ]
  stackscript_id = linode_stackscript.configure_db_server.id
  stackscript_data = {
    "DB_NAME" = var.DB_NAME,
    "DB_USER" = var.DB_USER,
    "DB_PASS" = var.DB_PASS,
    "PG_HBA_ENTRY" = "host all all all md5"
  }
}
resource "linode_instance" "database2" {
  image = "linode/ubuntu20.04"
  type = "g6-nanode-1"
  label = "${local.app_name}-db2"
  group = "${local.app_name}-group"
  region = var.REGION
  authorized_keys = [ linode_sshkey.ssh_key.ssh_key ]

  stackscript_id = linode_stackscript.configure_db_server.id
  stackscript_data = {
    "DB_NAME" = var.DB_NAME,
    "DB_USER" = var.DB_USER,
    "DB_PASS" = var.DB_PASS,
    "PG_HBA_ENTRY" = "host all all samenet md5"
  }

  interface {
    purpose = "public"
  }
  interface {
    purpose   = "vpc"
    subnet_id = linode_vpc_subnet.vpc_subnet.id
    ipv4 {
      vpc = var.DB_PRIVATE_IP
    }
  }
} As with the application servers, the two database servers are mostly the same, with just a couple of key differences: The second database includes configuration to add it to the VPC. Different settings are written to the Client Authentication file ( ). Database #1 allows all internet connections ( ) while database #2 only allows access from the same network ( ). [pg_hba.conf](https://www.postgresql.org/docs/current/auth-pg-hba-conf.html) "host all all all md5" "host all all samenet md5" It’s also worth noting that we explicitly assign the server’s private IP address when configuring the VPC settings ( ). This is the same static value that was given to the application server so it can connect to the database from within the VPC. var.DB_PRIVATE_IP Closing Hopefully, this post has opened our eyes to what VPCs are, why they’re cool, and when you might consider one. It’s like having your own little private internet. It’s not strictly a replacement for VLANs or firewalls, but it’s a great addition to any existing security practice or at least something to keep in the back of your head. Building out the demo was interesting in itself, and there were a lot of things that were totally new to me. I spent a lot of time learning: What VPCs are and how they work. It was my first time using Terraform, so that involved installation, usage, terminology, etc. I’ve used Postgres before, but have never had to manually configure client access. This was my second project using Drizzle and although it was very limited, the migrations process was challenging. I learned more than I care to know about networking, computer interfaces, IP ranges, and CIDR. I have much more respect for folks working on the networking layer. Linode StackScripts are also super cool. It was my preferred way to configure a server using Terraform, and I want to see how they work otherwise. There were also a couple of resources that I found particularly helpful: Linode’s VPC documentation Terraform’s Linode provider documentation And in case you want to keep going on with this or related topics, Talia put together some excellent posts recently: Talia’s review of DeveloperWeek Introduction to Akamai’s VPC Crafting a Resilient VPC Landscape using Terraform When should I use a Private IP vs. VLAN vs. VPC? And of course, if you are interested in trying out the VPC or any other Akamai cloud computing products, new users can sign up at and get $100 in free credits :) linode.com/austingil Thank you so much for reading. If you liked this article, and want to support me, the best ways to do so are to , , and . share it sign up for my newsletter follow me on Twitter Originally published on . austingil.com

How I Deployed My Own Lil' Private Internet (a.k.a. VPC)

Building new software always comes with unknowns. We try to reduce these with research, but there are always unanswered questions about what users truly need. This is where (MVPs) come in. As engineers, we need to strike a balance between overly loose “cowboy architecture” and building with future scale in mind. The database schema of an MVP is particularly critical. It determines the application’s data model, so flexibility is important. Yet, we need enough structure to avoid problems when it’s time to scale. Minimum Viable Products A Three-Step Process for Designing the Right Schema 1. Extrapolate to the Edges To understand an idea, take it to extremes – both big and small. This helps expose where it breaks down. Apply this to your MVP with non-functional requirements: How should the system perform at its absolute design limits? You likely don’t need planet-scale planning, but consider how it should behave once you hit traction. 2. Identify First-Class Objects These are entities with identities independent of others. A common example is a ‘User’. In e-commerce, a ‘Purchase Order’ (PO) might be one.  An ‘Invoice’, however, is dependent on a PO and thus wouldn’t be first-class. 3. Visualize Diagrams are powerful! Create a visual representation of your schema to see how things relate. This exposes potential complexity. Tools like ERD Editor in VSCode work well for MVPs. An Example I’m working on a SaaS app with GitHub-inspired access control for individuals, teams, and organizations. I used this process for my database design: : Defined desired features & performance at scale. Extrapolation : ‘Users’, ‘Organizations’, and ‘Roles’ needed independent existence for flexibility. First-Class Objects : The diagram helped me simplify and spot issues in relationships. Visualization Features/Capabilities Individual user accounts Organization accounts Users can belong to zero or more organizations Team support Organizations can have zero or more teams Role-based access control that is flexible Different roles for users in different organizations Non-Functional Requirements Simple to grok schema Flexible Role-based ACL Be performant at this scale: 1000-5000 Organizations 10-20 Teams per Organization 5-20 User per Team 100,000-500,000 Users Limitations A note on the limitations – for the sake schema simplicity and flexibility I chose to handle the limitations with business logic in code. Organization Owner -  Schema lacks enforcement of an organization “owner” Unique Organization/Team Names - Schema lacks normalization of , Organization.name Team.name schema & Diagram I used ORM to generate the SQL. I’ve shared my schema as a gist: “ .” Take a look for specifics. Prisma Flexible Multi-Tenant Web App Prisma Schema Summary Building a database schema for an MVP that scales well means finding the middle ground between adaptability and thoughtful planning. Follow these steps to get closer to that balance, as the perfect answer at the outset is unlikely. Also published here.

Designing the Right Database Schema for Your MVP Web App: A Three-Step Process

108 Stories To Learn About Website Design

In the dynamic world of iOS development, data persistence frameworks are of great importance in creating apps that are efficient and reliable. Historically, iOS developers have used Core Data or third-party libs such as Realm to store their data layers. Despite that, Swift Data was launched in 2023, providing programmers with a tool that consolidates the robustness of Core Data and the convenience and modern features of Swift. This article will dig into detail the difference between Swift Data and its predecessors, Core Data, and Realm, and also will give insights into its use for iOS projects. Swift Data: The Newcomer Swift Data, which was announced together with the new Xcode 14, is the most recent addition to Apple's suite of frameworks which are used for iOS, iPadOS, macOS, watchOS, and recent visionOS development. It uses the SwiftUI framework, using all the new language features of modern Swift and offering a declarative syntax for data binding and persistence. SwiftData builds upon the basic concepts of CoreData but simplified the developer experience by removing the boilerplate code and supporting concurrency naturally with the Swift programming style. Key Features of Swift Data: Declarative Syntax: Swift Data adopts macro and property wrapper syntax that is easier and needs less code to establish data models as compared to Core Data. Built-in Concurrency Support: Intended for advanced utilization, Swift Data offers excellent support for both modern-day asynchronous data operations and multi-threaded environment management, which are free from the complexity characteristic of Core Data. Seamless Integration with SwiftUI: Swift Data is built to be easy to use with SwiftUI, providing a way for data updates on the UI side with minimal work. Automatic iCloud Synchronization: With CloudKit as a backbone, Swift Data supplies a ‘synchronizing data across devices’, a feature that Core Data users need to customize. Core Data: The Veteran Core Data as a default framework for data persistence in iOS programming has been around for more than a decade. It is a powerful and flexible object-relational mapping framework, aka ORM, using which you can construct complex data models, relationships, and querying capabilities. One main advantage of Core Data is that it is very mature, and this has resulted in many resources to help you understand its workings, and a large support community of developers. When to Choose Core Data: Complex Data Models: Core Data has rich relationships and inheritance hierarchies, and along with its effective querying abilities, provide it with the capability to handle complex data requirements of applications. Legacy Projects: With regard to the Core Data projects that are already there, the performance gains of a migration to Swift Data may be not that sufficient to offset the cost of the migration. Realm: The Alternative Realm, which is widely adopted in mobile development, both Android and iOS, with different platforms, is a well-known third-party database. It is also known for the speed and simplicity made available through the easy-to-use API that allows one to store and retrieve data. Rising as a real-time and reactive tech enabler, Realm is an obvious option for performance and multi-platform applications. Advantages of Realm Over Core Data: Cross-Platform Support: Realm databases can be synced across iOS, Android, and other platforms, an important fact that would make the option appealing for multi-platform projects . Simplified API: Realm is much less complex than Core Data - it brings the developers API which is simpler and makes it easier for new developers to start. Performance: Realm is designed specifically to have a better performance, and indeed many times, it performs better than Core Data in benchmarks, particularly when dealing with write-heavy operations. Comparison: Swift Data vs Core Data vs Realm The decision to select between Swift Data, Core Data, and Realm can be based on a number of factors. For instance, it could be the project requirements, a team's previous experience with the frameworks, and the level of platform integration desired. Ease of Use: Swift Data and Realm are pretty newbie-friendly due to their simpler APIs and better compatibility with the latest Swift features. Core Data is simply more powerful but also has a steeper learning curve. Performance: Realm typically delivers a better speed and especially excels at writing operations. Swift Data aims at providing simplicity with performance by offering a readily usable framework as fast as Core Data without the burden of adding complexity. Integration with SwiftUI: Swift Data definitely stands out as the most favorable option since it is designed to have a seamless integration into SwiftUI, and reactive data updates are provided ex-factory. Is Swift Data the Future? Swift Data could be considered a game-changer in terms of data persistence in iOS development since it simplifies the whole process. Its compatibility with SwiftUI and modern Swift features make it an attractive option for new projects if you want to use a new tech stack. Nonetheless, the age and versatility of Core Data make it a good choice for advanced or legacy applications. Realm remains a valid option, particularly for projects that require cross-platform support or those projects where more attention to performance is needed. Conclusion In the end, the use of Swift Data, Core Data, or Realm will depend on the specific needs of your project and your team's skills. Swift Data experimentation and prototyping will give you an idea about its benefits and also will help to decide whether it meets your project's requirements. Swift Data definitely will grow and get more support in the future which could make it the preferred option to store data in iOS, especially for those who are 100% with Swift and SwiftUI.

Swift Data vs. Core Data vs. Realm: iOS Data Persistence Overview and Analysis

This paper is under CC 4.0 license. available on arxiv Authors: (1) Macoto Kikuchi (菊池誠), Cybermedia center, Osaka University, and Department of Physics, Osaka University and kikuchi.macoto.cmc@osaka-u.ac.jp. Table of Links Introduction Model and Methods Results Discussion and Acknowledgment IV. DISCUSSION The results presented in this paper suggest that the one-way switches are hardly selected in evolution because mutationally robust GNRs are favored. This scenario of the phenotype selection was confirmed by comparing the outcomes of the multicanonical ensemble method and the steady state of stochastic evolutionary simulations because the steady state does not depend on the evolutionary history. We consider this selection mechanism to be widely valid and not restricted to the case studied in this paper. Since this phenotype selection can occur whenever more than one phenotype exists for the same fitness value, we expect this phenomenon to occur in real living systems. We may call it the third-order selection because it is a consequence of the second-order selection. Since the second-order selection is a weak effect, the above phenotypic selection may be a further weak effect. However, as the present results suggest, the phenomenon may become significant if the steady state of evolution is maintained. Such situations can be realized experimentally. For example, it will be possible for the effect to be observed for bacteria under constant stress. It should be noted that what is the matter is not the absolute strength of mutational robustness but its relative strength. Thus, phenotype selection can occur even between mutationally not-so-robust phenotypes. Next, let us consider an implication of the evolution of the model dealt with observed in this paper. The result of McMC shows that most GRNs are monostable at low fitness; then as fitness increases the toggle switches dominate, and eventually most GRNs become one-way switches. A one-way switch of GRN realizes an irreversible change in the cell states. We note that irreversibility was not required in the definition of fitness. Thus, the irreversible switches can emerge even without it being required explicitly as fitness. It suggests the possibility that the irreversibility observed for real cells has evolved from the monostable reversible GRNs. Finally, the present study shows that McMC is an effective method for investigating characteristic properties of evolution. McMC clarifies what kind of phenotypes can exist if the evolution process is not considered. The fact that the outcomes of McMC and evolutionary simulation differ considerably implies a possibility that some phenotypes are not reached by evolution. Considering the experimental situation, such phenotypes may be accessible by direct genome engineering other than evolutionary experiments. Apart from the evolution of living systems, the present results give an insight into the genetic algorithm (GA) of optimization problems; GA is not a fair method for optimization; rather, it will provide the phenotypes bearing a specific property, namely, the mutational robustness, as the optimized solutions. ACKNOWLEDGMENTS This work was supported by JSPS KAKENHI Grant Number 23K03261. [1] H. Kitano, Biological robustness, Nat Rev Genet 5, 828 (2004). [2] A. Wagner, Robustness and Evolvability in Living Systems (Princeton Univ Press, 2005). [3] J. Masel and M. L. Siegal, Robustness: mechanisms and consequences, Trends Genet 25, 395 (2009). [4] G. Giaever, A. M. Chu, L. Ni, C. Connelly, L. Riles, S. Veronneau, S. Dow, A. Lucau-Danila, K. Anderson, B. Andre, A. P. Arkin, A. Astromoff, M. E. Bakkoury, R. Bangham, R. Benito, S. Brachat, S. Campanaro, M. Curtiss, K. Davis, A. Deutschbauer, K. D. Entian, P. Flaherty, F. Foury, D. J. Garfinkel, M. Gerstein, D. Gotte, U. Gludener, J. H. Hegemann, S. Hempel, Z. Herman, D. F. Jaramillo, D. E. Kelly, S. L. Kelly, P. Kotter, D. LaBonte, D. C. Lamb, N. Lan, H. Liang, H. Liao, L. Liu, C. Luo, M. Lussier, R. Mao, P. Menard, S. L. Ooi, J. L. Revuelta, C. J. Roberts, M. Rose, P. RossMacdonald, B. Scherens, G. Schimmack, B. Shafer, D. D. Shoemaker, S. Sookhai-Mahadeo, R. K. Storms, J. N. Strathern, G. Valle1, M. Voet, G. Volckaert, C. Y. Wang, T. R. Ward, J. Wilhelmy, E. A. Winzeler, Y. Yang, G. Yen, E. Youngman, K. Yu, H. Bussey, J. D. Boeke, M. Snyder, P. Philippsen, R. W. Davis, and M. Johnston, Functional profiling of the saccharomyces cerevisiae genome, Nature 418, 387 (2002). [5] T. Baba, T. Ara, M. Hasegawa, Y. Takai, Y. Okumura, M. Baba, K. A. Datsenko, M. Tomita, B. L. Wanner, and H. Mori, Construction of escherichia coli k-12 in-frame, single-gene knockout mutants: the keio collection, Mol Syst Biol 2, 2006.0008 (2006). [6] D. U. Kim, J. Hayles, D. Kim, V. Wood, H. O. Park, M. Won, H. S. Yoo, T. Duhig, M. Nam, G. Palmer, S. Han, L. Jeffery, S. T. Baek, H. Lee, Y. S. Shim, M. Lee, L. K. and. K. S. Heo, E. J. Noh, A. R. Lee, Y. J. Jang, K. S. Chung, S. J. Choi, J. Y. Park, Y. Park, H. M. Kim, S. K. Park, H. J. Park, E. J. Kang, H. B. Kim, H. S. Kang, H. M. Park, K. Kim, K. Song, K. B. Song, P. Nurse, and K. L. Hoe, Analysis of a genome-wide set of gene deletions in the fission yeast schizosaccharomyces pombe, Nat Biotechnol 28, 617 (2010). [7] M. Isaran, C. Lemerle, K. Michalodimitrakis, C. Horn, P. Beltrao, E. Raineri, M. Garriga-Canut, and L. Serrano, Evolvability and hierarchy in rewired bacterial gene networks, Nature 452, 840 (2008). [8] E. van Nimwegen, J. P. Crutchfield, and M. Huynen, Neutral evolution of mutational robustness, Proc Natl Acad Sci USA 17, 9716 (1999). [9] S. Ciliberti, O. C. Martin, and A. Wagner, Robustness can evolve gradually in complex regulatory gene networks with varying topology, PLoS Comput Biol 3, e15 (2007). [10] S. Ciliberti, O. C. Martin, and A. Wagner, Innovation and robustness in complex regulatory gene networks, Proc Natl Acad Sci USA 104, 13591 (2007). [11] B. A. Berg and T. Neuhaus, Multicanonical algorithms for first order phase transitions, Phys Lett B267, 249 (1991). [12] B. A. Berg and T. Neuhaus, Multicanonical ensemble: A new approach to simulate first-order phase transitions, Phys Rev Lett 68, 9 (1992). [13] Y. Iba, N. Saito, and A. Kitajima, Multicanonical mcmc for sampling rare events: an illustrative review, Ann Inst Stat Math 66, 611 (2014). [14] A. Kitajima and M. Kikuchi, Numerous but rare: An exploration of magic squares, PLoS ONE 10, e0125062 (2015). [15] N. Saito and M. Kikuchi, Robustness leads close to the edge of chaos in coupled map networks: toward the understanding of biological networks, New J Phys 15, 053037 (2013). [16] S. Nagata and M. Kikuchi, Emergence of cooperative bistability and robustness of gene regulatory networks, PLoS Comput Biol 16, e1007969 (2020). [17] T. Kaneko and M. Kikuchi, Evolution enhances mutational robustness and suppresses the emergence of a new phenotype: A new computational approach for studying evolution, PLoS Comput Biol 18, e1009796 (2022). [18] Y. Omachi, N. Saito, and C. Furusawa, Rare-event sampling analysis uncovers the fitness landscape of the genetic code, PLoS Comput Biol 19, e1011034 (2023). [19] J. J. Tyson, K. C. Chen, and B. Novak, Sniffers, buzzers, toggles and blinkers: dynamics of regulatory and signaling pathways in the cell, Curr Opin Cell Biol 15, 221 (2003). [20] J. E. Ferrell and E. M. Machleder, The biochemical bases of an all-or-none cell fate switch in xenopus oocytes, Science 280, 895 (1998). [21] E. Mjolsness, D. H. Sharp, and J. Reinitz, A connectionist model of development, J Theor Biol 152, 429 (1991). [22] A. Wagner, Evolution of gene networks by gene duplications: A mathematical model and its implications on genome organization, Proc Natl Acad Sci USA 91, 4387 (1994). [23] A. Wagner, Does evolutionary plasticity evolve, Evolution 50, 1008 (1996). [24] M. L. Siegal and A. Bergman, Waddington’s canalization revisited: developmental stability and evolution, Proc Natl Acad Sci USA 99, 10528 (2002). [25] J. Masel, Genetic assimilation can occur in the absence of selection for the assimilating phenotype, suggesting a role for the canalization heuristic, J Evol Biol 17, 1106 (2004). [26] K. Kaneko, Evolution of robustness to noise and mutation in gene expression dynamics, PLoS one 2, e434 (2007). [27] C. Espinosa-Soto, O. C. Martin, and A. Wagner, Phenotypic robustness can increase phenotypic variability after nongenetic perturbations in gene regulatory circuits, J Evol Biol 24, 1284 (2011). [28] M. Inoue and K. Kaneko, Cooperative adaptive responses in gene regulatory networks with many degrees of freedom, PLoS Comput Biol 9, e1003001 (2013). [29] M. Inoue and K. Kaneko, Cooperative reliable response from sloppy gene-expression dynamics, Eutophys Lett 124, 38002 (2018). [30] F. Wang and D. P. Landau, Efficient, multiple-range random walk algorithm to calculate the density of state, Phys Rev Lett 86, 2050 (2001). [31] F. Wang and D. P. Landau, Determining the density of states for classical statistical models: A random walk algorithm to produce a flat histogram, Phys Rev E 64, 056101 (2001). [32] J. Lee, New monte carlo algorithm: Entropic sampling, Phys Rev Lett 71, 211 (1993).

Phenotype Selection due to Mutational Robustness: Discussion & Acknowledgment

Let’s explore the Unit of Work Pattern in C# for Clean Architecture! Clean Architecture is a popular paradigm in software engineering, and understanding the Unit of Work Pattern is a helpful pattern we can leverage when developing tidy, maintainable, and understandable code. We can put these two concepts together to help us build solid applications. The Unit of Work Pattern is a that provides an efficient way of handling database transactions. It is a part of the n-tier architecture that separates the business logic from the data access logic. This pattern helps developers focus on the code’s functionality, abstract the database layer, and improve the overall code quality. design pattern Clean Architecture is designed to achieve maintainable, flexible, and testable code that can be easily changed or adapted, making the code more resilient to change. It fosters the separation of concerns within a software project, which improves the code quality, performance, and maintainability. In the following sections, I will explain the Unit of Work Pattern, Clean Architecture, and how they work together. We’ll see some practical tips and code examples that will help you enhance your skills and knowledge of both of these topics! Understanding the Unit of Work Pattern in C# The Unit of Work pattern is a design pattern used in software engineering to manage database transactions. It is responsible for coordinating multiple repositories to ensure consistency and atomicity of database transactions. The Unit of Work pattern provides several benefits, including improved performance, reduced coupling between repositories and the database, and easier testability. To implement the Unit of Work pattern in C#, follow these steps: Define an interface for the Unit of Work class that implements a variety of methods, such as and . Commit() Rollback() Create a concrete implementation of the Unit of Work interface that manages the lifetime of the database context object. Define an interface for the repository class that implements methods like . Add(), Update(), and Delete() Create a concrete implementation of the repository interface that utilizes the Unit of Work for transaction management. Below is an example of how to implement the Unit of Work pattern in C#: public interface IUnitOfWork
{
    void Commit();
    void Rollback();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly IDbContext _dbContext;

    public UnitOfWork(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Commit()
    {
        _dbContext.SaveChanges();
    }

    public void Rollback()
    {
        // Rollback logic here
    }
}

public interface IRepository<T>
{
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

public class Repository<T> : IRepository<T> where T : class
{
    private readonly DbSet<T> _dbSet;

    public Repository(IDbContext dbContext)
    {
        _dbSet = dbContext.Set<T>();
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
    }

    public void Update(T entity)
    {
        _dbSet.Attach(entity);
    }

    public void Delete(T entity)
    {
        _dbSet.Remove(entity);
    }
} By implementing the Unit of Work pattern in C#, you can easily manage database transactions using a single interface, reduce coupling between repositories and the database, and simplify testing of your data access layer. Clean Architecture in C# Clean approach that prioritizes the separation of concerns and the independence of frameworks and tools. This approach is centered around the idea of creating software systems that are easy to read, maintain, and test. architecture is a software design One of the core benefits of Clean Architecture is that it promotes an organized, maintainable, and scalable software structure that is easy to maintain over the lifetime of a project. Another benefit is that it promotes a focus on business logic over infrastructure and implementation details, which allows developers to design and build software systems that are more adaptable to change. When used in conjunction with the Unit of Work Pattern, Clean Architecture can become even more powerful, as it provides a clear separation of concerns between business logic and data access. By abstracting away the database implementation details into the Unit of Work Pattern, applications can become more flexible and easier to test. Some of the key benefits of using Clean Architecture are: Increased flexibility Easier testing Improved maintainability Separation of concerns Reduced coupling To see the benefits of Clean Architecture in action, consider the following code example: // this is an example of a (potentially) poorly organized, tightly-coupled code structure
// - directly accessing the DB context to fetch
// - directly accessing the DB context to write
public class MyClass
{
    private readonly IDbContext _dbContext;

    public MyClass(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void DoSomething(int id)
    {
        var entity = _dbContext.Set<Entity>().FirstOrDefault(e => e.Id == id);

        // ...

        _dbContext.SaveChanges();
    }
}

// this is an example of a clean code structure using Clean Architecture
// - using a repository interface to read
// - using a unit of work pattern to write
public class MyClass
{
    private readonly IRepository<Entity> _entityRepository;
    private readonly IUnitOfWork _unitOfWork;

    public MyClass(IRepository<Entity> entityRepository, IUnitOfWork unitOfWork)
    {
        _entityRepository = entityRepository;
        _unitOfWork = unitOfWork;
    }

    public void DoSomething(int id)
    {
        var entity = _entityRepository.GetById(id);

        // ...

        _unitOfWork.Commit();
    }
} By adopting Clean Architecture in conjunction with the Unit of Work Pattern, developers can create more scalable, maintainable, and testable software systems that are easier to work with over the lifetime of a project. By focusing on independent modules with well-defined interfaces, developers can achieve increased flexibility and reduced coupling, which leads to systems that are easier to evolve and extend over time. Implementing the Unit of Work Pattern in Clean Architecture To implement the Unit of Work pattern in Clean Architecture, use the following steps: Define an interface for the Unit of Work class that includes methods to manage database transactions, such as and . Commit() Rollback() Create a concrete implementation of the Unit of Work interface that manages the lifetime of the database context object. This should be done in the outer-most layer of the application, which may be a database access layer or a service layer. Define an interface for each repository class that includes methods like . These methods should use the Unit of Work to manage database transactions. Add(), Update(), and Delete() Create concrete implementations of each repository interface using a specific database implementation (like Entity Framework). Code Example of the Unit of Work Pattern in Clean Architecture Here is an example code structure for implementing the Unit of Work Pattern in Clean Architecture: // Application Layer
public interface IUnitOfWork
{
    void Commit();
    void Rollback();
}

public class UnitOfWork : IUnitOfWork
{
    private readonly IDbContext _dbContext;

    public UnitOfWork(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Commit()
    {
        _dbContext.SaveChanges();
    }

    public void Rollback()
    {
        // Rollback logic here
    }
}

// Domain Layer
public interface IEntityRepository<T>
{
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

public class EntityRepository<T> : IRepository<T> where T : class
{
    private readonly DbSet<T> _dbSet;

    public EntityRepository(IDbContext dbContext)
    {
        _dbSet = dbContext.Set<T>();
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
    }

    public void Update(T entity)
    {
        _dbSet.Attach(entity);
    }

    public void Delete(T entity)
    {
        _dbSet.Remove(entity);
    }
}

// Infrastructure Layer (Entity Framework-specific implementation)
public class EntityFrameworkDbContext : IDbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("your-connection-string-here");
    }

    public DbSet<Entity> Entities { get; set; }
}

public class EntityFrameworkUnitOfWork : IUnitOfWork
{
    private readonly EntityFrameworkDbContext _dbContext;

    public EntityFrameworkUnitOfWork(EntityFrameworkDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void Commit()
    {
        _dbContext.SaveChanges();
    }

    public void Rollback()
    {
        // Rollback logic here
    }
}

public class EntityFrameworkEntityRepository<T> : IEntityRepository<T> where T : class
{
    private readonly EntityFrameworkDbContext _dbContext;
    private readonly DbSet<T> _dbSet;

    public EntityFrameworkEntityRepository(EntityFrameworkDbContext dbContext)
    {
        _dbContext = dbContext;
        _dbSet = dbContext.Set<T>();
    }

    public void Add(T entity)
    {
        _dbSet.Add(entity);
    }

    public void Update(T entity)
    {
        _dbSet.Attach(entity);
    }

    public void Delete(T entity)
    {
        _dbSet.Remove(entity);
    }
} Benefits of Implementing the Unit of Work Pattern in Clean Architecture Implementing the Unit of Work pattern in Clean Architecture provides many benefits, including improved code maintainability, scalability, and testability. The following are the key benefits of this approach: By abstracting away the lower-level database code into the Unit of Work pattern, this implementation reduces coupling between the repository layer and the database. This makes it easier to switch out database implementations or make database schema changes without affecting higher-level business logic in the application’s layers. Reduced Coupling: The Unit of Work pattern makes it easier to maintain the application codebase since developers don’t need to worry about managing multiple database connections or transactions. This makes the code cleaner and easier to understand. Additionally, using the Clean Architecture approach means that different layers of the application are organized according to their concerns, which further improves maintainability. Improved Maintainability: With the Unit of Work pattern and Clean Architecture approach, developers can more easily test the application. They can create mock objects for the repository classes and Unit of Work and test business logic without creating integration tests with a database. This makes testing faster, less brittle, and saves valuable development time. Simplified Testing: By implementing the Unit of Work pattern in Clean Architecture, developers can build applications that are flexible, maintainable, and scalable. The separation of concerns enabled by the clean architecture approach makes it easier to maintain or change code over time with minimal impact on other application layers. Finally, this approach provides developers with a simplified testing process that helps them write better code faster. Common Mistakes & Suggestions for the Unit of Work Pattern Despite the many benefits of the Unit of Work pattern in C#, there are several common mistakes that developers make when implementing this design pattern. Some of these mistakes can lead to bugs, poor performance, or other issues that affect the overall quality of the software. Common Mistakes When Implementing the Unit of Work Pattern The following are some common mistakes made when implementing the Unit of Work pattern: : The Unit of Work pattern is intended to simplify data access by providing a single interface for database transactions. However, some developers overcomplicate this interface by including unnecessary methods or business logic. This results in bloated and difficult-to-understand code. Overcomplicating the Unit of Work : One of the main benefits of the Unit of Work pattern is the ability to manage transactions using the Commit() and Rollback() methods. However, some developers fail to manage these transactions properly, which can result in partial updates or corrupted data. Not properly managing transactions : If the Unit of Work pattern is not properly abstracted from the database layer, developers may end up with tight coupling between their application and the database. This can make it difficult to make changes to the database schema or switch to a new database technology and may result in poor performance. Failing to properly abstract the database layer Suggestions When Implementing the Unit of Work Pattern To avoid these common mistakes, it’s important to follow best practices when implementing the Unit of Work pattern. Some tips for avoiding these mistakes include: : The Unit of Work interface should only include the methods necessary to manage transactions. Additional business logic should be kept in the repository layer or other parts of the application. Keeping the Unit of Work simple : Developers should ensure that transactions are properly managed using the and methods. If possible, developers should use a transaction scope to ensure that transactions are atomic and consistent. Implementing the Unit of Work correctly Commit() Rollback() : The Unit of Work pattern should be properly abstracted from the database layer to allow for flexibility and maintainability. This can be accomplished by using an ORM-like Entity Framework that provides a layer of abstraction between the application and the database. Abstracting the database layer By following these tips and avoiding common mistakes, developers can implement the Unit of Work pattern in a way that maximizes its benefits and improves the overall quality of their software. Wrapping Up the Unit of Work Pattern in C# for Clean Architecture The Unit of Work Pattern in C# for Clean Architecture can be very helpful for software engineers to follow. It allows for better separation of concerns, simpler code maintenance, improved testability, and easier scalability. By utilizing Clean Architecture with the Unit of Work pattern, you can take full advantage of the many benefits that both of these offer. By using the tips and techniques outlined in this article, you can take your software engineering skills to the next level and create more robust and scalable applications. Fall back to the code examples to see how the pattern can work in its basic form, and see if it makes sense for you while implementing clean architecture. Try with Clean Architecture in your project! Doing so can contribute to more efficient development processes and more successful software outcomes. implementing the Unit of Work pattern Also published here.

Using the Unit of Work Pattern in Clean Architecture for C#

If you have ever worked on a Spring application using Hibernate 5, you probably encountered the challenge of dealing with duplicated entities. It is an odd scenario where your collection contains multiple entries referencing the same entity. This is a quite known issue, and there are ways to address it whether using the keyword, Sets, or JPA EntityGraph. DISTINCT However, I happened to have quite disturbing behavior using EntityGraph returning duplicated entities! We will be diving a bit under the hood of Hibernate 5 to understand what happened. A Simple Spring Boot Application To illustrate Hibernate 5 behavior, let’s start with a basic Spring Boot project connected to a database: https://github.com/Shaolans/HibernateEntityGraphDeduplicationIssue The database schema is a simple model as follows: The Hibernate entities are defined as follows: Our focus will be on the queries generated by this JPA repository: @Repository
public interface AuthorRepository extends JpaRepository<Author, Integer> {

    @Query("SELECT a FROM Author a LEFT JOIN FETCH a.books")
    List<Author> findAuthorsLeftJoinFetchNoEntityGraph();

    @EntityGraph(attributePaths = "books")
    @Query("FROM Author a LEFT JOIN a.books")
    List<Author> findAuthorsLeftJoinWithEntityGraph();

    @Query("FROM Author a LEFT JOIN a.books")
    List<Author> findAuthorsLeftJoinWithoutEntityGraph();

    @EntityGraph(attributePaths = "books")
    @Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
    List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph();

    @EntityGraph(attributePaths = "books")
    @Query("SELECT a FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
    List<Author> findAuthorsWithJoinNotFetchedAndEntityGraphAndSelect();
} Entity Duplication Why Does It Happen? To understand the occurrence of entity duplication, let’s consider a use case where the objective is to retrieve all authors and their respective books. In order to avoid the issue I include in my JPQL query the keyword . N+1 query FETCH It enables the retrieval of both authors and their associated books in a single SQL query, eliminating the necessity to individually fetch books for each author. @Query("SELECT a FROM Author a LEFT JOIN FETCH a.books")
List<Author> findAuthorsLeftJoinFetchNoEntityGraph(); Invoking this method will result in the compilation of an SQL query equivalent to the following: SELECT A, B FROM AUTHOR A LEFT JOIN BOOK B ON A.ID = B.BOOK_AUTHOR_ID; In a case where you have 2 authors that have respectively 2 and 3 books, the result of the SQL query will yield the following table: Depending on the type of used, the association between the and tables are established based on the provided condition. join Author Book This will produce for each that matched an , a new row containing the columns of the table but also the columns of the table. Book Author Book Author Hibernate, upon retrieving this result set, intelligently resolves the entity without duplication. In our case, we end up with only two instances of the entity. However, it handles resolution on a row-by-row basis and does not inherently deduplicate the rows by default. Author This explains why the , returned by calling , returns the following collection: List findAuthorsLeftJoinFetchNoEntityGraph [Author@5640, Author@5640, Author@5641, Author@5641, Author@5641] being the instance representing J.R.R Tolkien entity and representing the Isaac Asimov. Author@5640 Author Author@5641 Author This duplication is mostly observed on and relationships since joining with these types of relations might match multiple rows of the associated table. @OneToMany @ManyToMany On the contrary, and relationships match at most only 1 entry on the associated table and will not induce duplication. @OneToOne @ManyToOne How to Deduplicate Although this duplication issue is quite common and often occurs during the development of applications, there are ways to address and resolve this issue. Set A straightforward solution involves using the returning type instead of : Set<Author> List<Author> @Query("FROM Author a LEFT JOIN FETCH a.books")
Set<Author> findAuthorsLeftJoinFetchNoEntityGraph(); When the results are collected, duplicated entities will be filtered through the . Set DISTINCT keyword Another approach is to use the keyword: DISTINCT @Query("SELECT DISTINCT a FROM Author a LEFT JOIN FETCH a.books")
List<Author> findAuthorsLeftJoinFetchNoEntityGraph(); It should be noted that using as two semantic meanings: DISTINCT : The conventional SQL meaning involves filtering duplicate values in the selected columns. SQL : It indicates a desire to filter duplications in the parent entity. Hibernate When the keyword is used in a JPQL query, it leads to the generation of an SQL query featuring the keyword but also instructing Hibernate to filter duplicated entities. DISTINCT DISTINCT However, using in SQL induces an overhead when executed in the database, and in some cases, the goal is to only filter duplicate entities induced by the join. For such cases, the Hibernate hint can be employed to avoid the generation of in the SQL query: DISTINCT HINT_PASS_DISTINCT_THROUGH DISTINCT @QueryHints(@QueryHint(name = HINT_PASS_DISTINCT_THROUGH, value = "false"))
@Query("SELECT DISTINCT a FROM Author a LEFT JOIN FETCH a.books")
Set<Author> findDistinctAuthorsLeftJoinFetchNoEntityGraph(); EntityGraph In JPA 2.1, EntityGraph was introduced as a powerful feature allowing developers to define the loading strategies of entities. In our case, we can just use the annotation to load the books along with the , as illustrated below: @EntityGraph Author @EntityGraph(attributePaths = "books")
@Query("FROM Author a LEFT JOIN a.books WHERE a.books.size > 2")
List<Author> findAuthorsLeftJoinWithEntityGraph(); This JPQL query is designed to retrieve all authors, along with their respective books, who possess more than 2 books. Even without explicitly including the keyword in the SQL query, the EntityGraph ensures the books are loaded and the parent entity remains non-duplicated. FETCH Author : This is a simple example of using EntityGraph; a more complete and sophisticated way of using it exists, but this is not the scope of this section. Note EntityGraph and Entity Duplication While it is established that EntityGraph handles entity deduplication, let's look into a more complicated scenario. Consider the entity, which has a relation with . Suppose the objective is to retrieve all authors and their books where the author's agent has a name containing "John", yet we have no intention of loading the entity for an arbitrary reason. In this case, we can accomplish this by the following code: Author @ManyToOne Agent Agent @EntityGraph(attributePaths = "books")
@Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); Since we are using EntityGraph, we expect to avoid duplicated , but upon executing the method, the outcome is unexpected: Author Duplicated entities are retrieved despite the use of EntityGraph. To understand the underlying reasons for this behavior, let’s dive a bit under the hood of Hibernate! How Hibernate Resolves Entity Duplication Hibernate is a quite complete and complex ORM, it can be hard to grasp entirely its fine details, but in our case, since we want to understand deduplication mechanisms, we will be focusing on the method of list . QueryTranslatorImpl For the sake of clarity, some portions of the code have been omitted in order to highlight the most crucial aspects. Upon invoking a method from the , the execution will eventually reach this code snippet. Here is a breakdown of its functionality: AuthorRepository It computes a boolean called , and as the name implies, it identifies whether the result set needs to be deduplicated. needsDistincting We can observe when we do use a keyword, EntityGraph, or limit the size of retrieval, there is a operation in the JPQL query; the distinction needs to be applied. DISTINCT AND FETCH In our issue, it can be observed that whenever EntityGraph is used, the distinction will be applied since EntityGraph will edit the source query to “ ” child entities given in the attribute paths. FETCH This method invocation executes the query in the database, retrieves the result set, and resolves the entities. This list might contain duplicated entities. This is the most interesting part here; when it does need to distinguish entities, Hibernate uses an to filter out the duplicated entity. IdentitySet At this point, it is established that using EntityGraph should filter duplicated entities, but what happened to cause the unexpected outcome previously discussed? Why EntityGraph Returns Duplicates in Some Cases Let’s Compare In order to have a better understanding of the situation, let’s compare the results of when invoking the following methods: queryLoader.list( session, queryParametersToUse ) (2) @EntityGraph(attributePaths = "books")
@Query("FROM Author a LEFT JOIN a.books")
List<Author> findAuthorsLeftJoinWithEntityGraph(); and @EntityGraph(attributePaths = "books")
@Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); Upon calling , the returned results contains: findAuthorsLeftJoinWithEntityGraph Given the EntityGraph is used, the duplication will be resolved through the , and at the end, the method will return a consisting of 3 authors/instances. IdentitySet List<Author> However, upon calling , the returned results contains the following: findAuthorsWithJoinNotFetchedAndEntityGraph In this scenario, the result is not a List of instances but rather a of distinct array instances of Objects; each encapsulating duplicated and instances. The reason behind the presence of duplicate entities becomes evident. Author List Author Agent Each array ( , , ..., ), being a unique instance, is not filtered during the distinction process with the . Object[2]@13551 Object[2]@135512 Object[2]@13555 IdentitySet Consequently, all arrays are considered as distinct instances, leading to the observed duplication. Explaining the Difference In order to understand the difference between obtaining a List of instances in the former case and a list of arrays containing and instances in the latter case, we need to explore deeper; let’s take a look at the class and especially the method . Author Author Agent QueryLoader initialize This initialization code has interesting parts, particularly the one highlighted in red. It creates an array of boolean where it checks which entities should be selected and be returned. includeInSelect Let’s take for example: @Query("SELECT a, b FROM Author a LEFT JOIN FETCH a.books b") The initialize method checks the content one by one which is and ; if the selected entity originates from a in the clause, then it will be omitted since is used to load children entities (but not in the case of the parent entity). Otherwise, the entity should be selected. SELECT a b FETCH FROM FETCH In this example, the array contains . includeInSelect [true (Author), false (Book)] In our case, of entity duplication with EntityGraph: @EntityGraph(attributePaths = "books")
@Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like 'John'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); We did not specify the clause, so by default, it will select all the entities from all the tables specified in the clause. SELECT FROM The logic returns an array where and (2 elements) should be selected because only is subject to a operation due to the use of EntityGraph. includeInSelect [true (Author), false (Book), true (Agent)] Author Agent Book FETCH This explains the difference between and . findAuthorsLeftJoinWithEntityGraph findAuthorsWithJoinNotFetchedAndEntityGraph The former returns only one value per row because the clause contained only and entities (the select of was generated by EntityGraph), however, since was subject to a , it was not taken into account in the . SELECT Author Book Book Book FETCH includeInSelect The latter returns an array per row because and were in the clause and are not subject to a operation unlike . Thus, returning an array consisting of 2 elements per row. Author Agent SELECT FETCH Book In summary, Hibernate consistently returns an array, and the content of this array is determined by the entities specified in the clause that are not associated with operations. SELECT FETCH However, if we follow the preceding logic, should also return an array but an array of a single element. This is accurate; it does. However, upon examining the implementation at ** **lines and , when the array consists of a single element, the element is just unwrapped. findAuthorsLeftJoinWithEntityGraph QueryLoader 476 620 How to Fix It To ensure correct duplicate filtering when applying a distinction, the result set should be a list of entities rather than a list of entity arrays. This behavior is determined by the entities selected. A straightforward solution is to include the desired entities in the clause: SELECT @EntityGraph(attributePaths = "books")
@Query("SELECT a FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); The clause will only contain and (the select being generated by the EntityGraph): SELECT Author Book Book Since is a operation, the will only select one element ( ), and instead of returning an array, it will return directly the instance which then will pass through the to be deduplicated. Book FETCH includeInSelect Author Author IdentitySet Conclusion Entity duplication occurs when tables are joined, and multiple rows are matched. There are several methods to address this issue, including using , the keyword, or EntityGraph to deduplicate the result set. Set DISTINCT In the last two cases, deduplication is achieved through a Hibernate flag that accumulates results into an . IdentitySet However, it may not work in certain scenarios due to the fact that, depending on your clause, it could return newly instantiated arrays of your selected entities for each row. This could undermine deduplication through the . SELECT IdentitySet Therefore, it is advisable, when writing JPQL queries, to always specify the clause. If not supplied, all entities in the clause that are not subject to a operation will be selected by default. SELECT FROM FETCH The issue of duplicated parent entities is addressed in Hibernate 6 (shipped in Spring Boot 3), as it has introduced automatic handling of duplicated entities. However, considering that the release of Hibernate 6 is relatively recent, many applications still run on Hibernate 5 or earlier versions, and migration from Hibernate 5 to 6 might be challenging. Thus, understanding how Hibernate 5 handles these situations remains relevant for the considerable number of applications still using it. Also published here

Stories, News & Mentions about ORUM

Orum’s Stories on HackerNoon