Best match

Most recent

What are the best io games? You might not be aware of the genre: accessible browser-based games that range from offline to MMO experiences. The best io games conjure ...

The best io games 2023

PCGamesN

Google IO 2023 is getting very close, with the search giant's big developer conference due to kick off later today (Wednesday, May 10). And it's shaping up to be a particularly big event for new ...

Google IO 2023: dates, rumors, plus all the Android 14, Pixel and AI news we expect

TechRadar

Browser-based .io games have been popular for a while now, and they’re a great way to pass some time whether you’re by yourself or just looking for something to play with a friend or two.

Top 25 Best Multiplayer .io Games

Twinfinite

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

SocialSentiment.io

Meet the Winners of Startups in North and Central America

The has been a popular choice for web development with for many years. And for good reason: it leverages Python's ease of modularity to offer a very flexible solution for a variety of applications. Django Framework Python Django's core features include a model-view-controller architecture, an ORM, a templating system, caching, internationalization, and many other things you'd expect in a modern web framework. "Applications" distributed with the system add features for authentication, an administrative interface which automatically provides CRUD operations for data models, multi-site support, and mitigation from common security threats. Possibly Django's greatest strength is that just about all of its features can be extended or overridden. This means you'll rarely feel restricted when implementing a feature, making it an ideal choice for complex and ever-growing applications. Here are some tips for making the best use of Django in your next SaaS app. SaaS Keep Your "Apps" Organized Every system built on top of Django is written as one or more "applications", as the framework calls them. Each application is a bundle of models, views, templates, and any other custom code needed to run some aspect of the website.  The built-in administrative system is one such application.  There are plenty of others freely available online.  Each is enabled in the settings file and their URL routes can be registered as part of your main configuration. When building a custom site it may seem natural to write everything into one such application. You'll quickly find your code growing as you add features. Just as it's a best practice to separate and organize your code by its responsibility, applications should be broken down in a similar way in Django. This allows each to stay focused on their primary task and also makes them much easier to and debug. unit test For example, let's say your site lets users manage subscriptions, has a section for authenticated users to view premium content, and public pages for marketing purposes. I would build each as a separate Django application. Since Django applications are Python modules, they can include functionality from each other as needed. The premium content app can leverage the model defined in the subscription app to check if a user should be allowed access. Use Django REST Framework for APIs The (DRF) is a highly flexible and customizable extension to Django for exposing APIs. With very little code it can expose CRUD operations directly against your data model. You can also write your own endpoints that leverage its other features, such as authentication and automatic documentation. Django REST framework I often write APIs that do not exactly match my data model and require customization. For me the biggest benefits of using Django REST framework over rolling my own solutions are the authentication, caching, and throttling options. The automatic documentation and extensions for things like are an added bonus. Swagger The small learning curve for DRF makes it well worth the investment for the value it adds. Throttle APIs Based on User Subscriptions A common business model of many SaaS applications today includes user subscriptions to APIs. Access to these APIs can be restricted to specific endpoints or rate limited based on subscription levels. Django REST framework supports both.  When adding s to I decided to throttle requests at different levels depending on subscription tier. This is not natively built into the framework. Fortunately just about every aspect of the system can be overridden. API SocialSentiment.io I chose to extend the DRF class: UserRateThrottle rest_framework.throttling UserRateThrottle scope = super().__init__() request.user.is_authenticated:
            user_daily_limit = get_user_limit(request.user) user_limits: self.duration = self.num_requests = user_daily_limit : self.rate : self.key = self.get_cache_key(request, view) self.key : self.history = self.cache.get(self.key, [])
        self.now = self.timer() self.history self.history[ ] <= self.now - self.duration:
            self.history.pop() len(self.history) >= self.num_requests: self.throttle_failure() self.throttle_success() from import : class SubscriptionRateThrottle (UserRateThrottle) # Custom scope required by DRF "subscription" : def __init__ (self) : def allow_request (self, request, view) """
        Override rest_framework.throttling.SimpleRateThrottle.allow_request
        """ if if # Override the default from settings.py 86400 else # No limit == unlimited plan return True # Original logic from the parent method... if is None return True if is None return True # Drop any requests from the history which have now passed the # throttle duration while and -1 if return return In this example a function will need to be written to retrieve a daily rate limit from the user's subscription. This class then needs to be added to the array within in . With just a few dozen lines of code we now have custom API rate throttling! get_user_limit DEFAULT_THROTTLE_CLASSES REST_FRAMEWORK settings.py Cache, Cache, Cache The key to a fast website is sending responses to the browser as fast as possible. Application level caching should be a component of this strategy. Django includes a caching interface which can be backed by just about anything. I recommend using via for a few reasons. Redis django-redis Redis has already proven itself as a fast, efficient, and convenient key-value store. As your SaaS system scales it will eventually need multiple servers / . By using a shared cache such as Redis across all instances you'll conserve resources. At launch you might even choose to warm the cache with certain information before the application starts to process requests. containers Redis has multiple options for . This means if you need to restart or move your system you do not need to lose all of your cached information. persistence Django's cache system offers built-in view level caching. Just about anything else, including data model instances, can be manually cached as well. Carefully leverage this wherever possible for huge performance gains. Settings for Each Environment Django loads its configuration from a file provided by your application. Secure information such as database passwords and keys can be stored here and should never be committed to your project's code repository. It's also very likely developer environments and test systems will need certain settings to differ from production deployments. settings.py There are two ways to handle this. Both are equally convenient and flexible. One solution is to use environment variables. being another Python file can simply inspect the mapping from the built-in module. With this method the settings file can still be committed to code and deployed as usual. This plays very nicely with deployments which often use environment variables for custom settings. settings.py environ os docker Another solution is to create a or similar file for common settings and a custom file which imports the base and overrides variables as needed. This may be more or less convenient depending on the details of your deployments to various environments. settings_base.py settings.py Settings to consider for SaaS applications include database parameters, user sessions, static file locations such as a CDN, and the cache configuration. Conclusion Python plus Django provides a robust and flexible solution for SaaS applications. They've proven their value and have a great community of support. I highly recommend trying it out for your next major project. I learned many of these lessons while building SocialSentiment.io, an application which performs social media sentiment analysis of stocks . Django has been a great choice and I'll share more lessons soon.

How To Use Django as Your SaaS Framework

Like many tools in the developer's toolbox, docker is relatively easy to jump into and takes some time to master. Using it for a variety of projects over the years I've learned a few lessons along the way. software Build Efficiently Each , , and command within a dockerfile produces a new disk image layer. These layers are cached to optimize rebuilding.  As explained in , "the layers are stacked and each one is a delta of the changes from the previous layer." RUN COPY ADD their documentation There are interesting consequences to this. Running many small commands in your build process can produce more changes and therefore larger layers. Altering any command since the last build will require docker to recreate that layer and all subsequent layers. It needs to execute all commands further down the dockerfile even if they haven't changed. After some research and much trial and error I've learned a pattern that helps my builds run faster and smaller: Start with one command to update the OS package manager and install OS dependencies. The last part should be a cleanup command to remove temporary and cached files. RUN Next one command to configure and enable the appropriate servers, e.g. a web server. RUN Next I any specialized configuration files and dependencies. During development I change these more often than standard OS dependencies. COPY Then comes a command for application runtime environments and package dependencies, such as Python's .  These are also combined into one command string. RUN pip Last I my application's code.  That's what changes most often so save it for the end. COPY This solved a major performance bottleneck I found with many of my builds.  It's common practice to commit application package dependency information with a codebase, such as Python's file or Node's . Therefore my first instinct was to run the runtime package manager after copying my codebase into the image.  Even if the required packages didn't change, the update to my codebase would force docker to trigger a re-install of all packages. requirements.txt package.json Adding individual commands for dependency manager files, such as , into the image during step 3 and executing the package manager on the next step, but before the custom code is copied, means it now only runs when package requirements change. COPY requirements.txt Clean Up After Yourself Docker's disk images are (thankfully) cached on local disk to save time during subsequent builds. During I find myself rebuilding quite often.  I'm upgrading or changing dependencies.  And I'm tweaking the dockerfile itself. In addition I'll experiment with 3rd party containers for just a day or two and forget about them.  Unused images will therefore pile up quickly. development While my project is up and running in my development environment I'll run the following command about once a week. > docker system prune This will remove cached images not tied to any containers that are currently running. If you have a build server such as Jenkins you'll want to perform similar cleanup periodically or after each build. When to Use docker-compose docker-compose is a great addition in that it saves us from writing long and complicated docker commands. It's perfect for local development and for sharing with others to spin up containers for tests and demonstrations. But my focus is in "enterprise" grade software. If you're hosting your own large SaaS application you're most likely running a platform through a vendor. If you distribute your docker images to big companies / clients, they likely are doing the same.  Don't expect docker-compose to satisfy these requirements. Plan to write and test deployment scripts and leverage the orchestration system's features to optimize scaling and uptime unique to each situation. container orchestration Stay Independent It's sometimes tempting to include connections from within docker containers out to their runtime environment. An obvious example is application logging.  If you run a consolidated logging and system it's usually trivial to hook this directly into your application.  Beware this makes your container very dependent on its environment and much harder to test and share. analysis It's a best practice to keep your container as agnostic as possible to its environment.  Use generic solutions when possible. Logs, for example, can be output to the console and redirected to a central logging system by the runtime environment outside the container. Even something as complex as authentication over the web can be handled by external systems and the necessary information passed into the container through headers.  This makes local development and testing much simpler and independent of those requirements. HTTP Where To Go From Here There's always more to learn with every technology we touch. Docker's own is a very informative. From there I suggest focusing on best practices specific to your . list of best practices orchestration platform Whatever you do, don't stop reading and experimenting. I learned many of these lessons while building SocialSentiment.io, an application which performs social media sentiment analysis of stocks . I plan on sharing more soon.

SocialSentiment.io News on
HackerNoon and Around the Web

Winner for Best Startup in Stamford, Us!

socialsentiment.io

-- employees

Since n.d.

SocialSentiment.io Story Mentions

Articles Around the Web

Read More Tech Stories Related to #SocialSentiment.io

SocialSentiment.io News on HackerNoon and Around the Web