DEV Community: Trabin

Heuristics are important

Trabin — Wed, 01 Oct 2025 05:52:45 +0000

Just like it says on the tin. Just some thoughts I have.

You can show them through ecology, like how many creatures share the same color that matches an element. Players can At-a-Glance and understand how to change their play style to adapt to that sort of battle, and it can be subtle but must be distinct.

But not every biome is going to have or need the same ecological creatures, but needs to fit particular parts of the ecosystem, such as being a part of the food chain in some way to be more collectively creating a live or living ecosystem, not just because those things exist. Why do they exist in the world and what does it do to either for or against to the environment.

How does introducing foreign objects or entities into this environment? What sort of general what would be innocuous things to the biome would probably eliminate this foreign entity? Would it strengthen it instead of destroy?

What about other factors such as the environment itself? Is it toxic to some, but not others? What if something is actually terraforming the environment itself? (Toxic fumes or spores/pollen, acid or other corrosive, burning things in a small or enclosed space) Lot's o' Factors

Similarly, in order for life to exist in a particular environment and become part of it's ecosystem is it's evolution to allow the thing to survive. That means it might feed off of specific flora or fauna that exists uniquely within that ecosystem, within that Biome

Carnivorous Plants tend to exist in places where the soil is habitually lacking in several things within the soil and strata so it had to adapt to a type of trap and method of breaking down other biological matter. Explosive and travelling plants usually live in places where it's difficult to propagate, like Deserts. Quick growing Climbing plants that choke the environment tend to live in temperate climates with copious amounts of Water, places already generally overrun with plants to begin with.

Arachnids, but specifically Spiders are one of the biggest examples of adaptability, having millions of different species. However, while everywhere has some more likely species based on population density and availability of food and food types within those areas, where you have more heat and humidity (with some exceptions, like Desert Tarantulas), you have more arachnids that consume the entire entity they hunt versus just draining an exoskeleton like a juice box. Where Scorpions take the most space in Deserts, and more thin legged spiders and orb weavers taking up colder climate locations.

So, Why talk about Heuristics? Because if you know what a Spider is and kind of what it eats, then you know how to kind of handle it. What do most spiders have? Webbing. What does Webbing do? It slows or stops something. What usually takes care of webbing? Soap, Fire, A big Stick? Whatever it is, you have to stick to it and Shtick to it, too, in order for it to make sense to your players. See Spider, kill with Fire. Bam. Doesn't matter what color, except for the Occasion that the Spider/Scorpion thing happens to be made of fire (Looking at You, Devil May Cry).

But it's the same things with like Movement, like all Octorocs walk in square patterns and shoot ink balls from their round mouths in the direction their facing, but you're also less likely to find an Octoroc far from beaches and plains in the Zelda Universe. You know how to handle them because of how they are and by how easily recognizable the enemy is, mimicking how small octopus move about the Japanese islands, as well as Japanese culture in general (Akkorokamui -Ainu).

Another example is Flans and Bombs from the Final Fantasy Universe, where the color that it is decides the element, and the fact that their general creature typing requires them to be attached predominantly by Magic Type attacks or in general the opposing elemental damage. Their Existence has been multiple times been tied directly to the amount of magic, either natural cleanup of Magic in the location feeding off of it or created as or for Magical Disasters themselves (FF4-6).

They Fit in their worlds, either made to fit or made because the world needed a reason or excuse to utilize a source that exists in that universe either for the environment or because of the environment, and has an explanation as to why it exists in that universe.

The same goes for their move set, how they interact with the players.

As an example, most games tend to introduce a slew of simple concepts of how their game's general move sets tend to work within the universe. Say like in a Metroidvania, you'll be introduced to a couple of general creature types but not in the way you would think.

Walkers move from side to side, or left to right.
Crawlers cling to the edges of their platforms, often doing full circles or going back and forth between points on a platform, usually actually being a change in the physical platform becoming the barrier to movement, but climbing crawlers might be along any edge at any time.
Bouncers will bounce off objects and walls and the player character.
Turret, the stationary shoot a projectile in the direction of the player with varied speed, usually slower than a crawl in the beginning.

From there, it becomes varied mixtures of the same things, and the introduction of tracking and pathfinding that goes from a Patrol state into an active or chase state before an attack or return to patrol state. Some even go back to their starting locations, some create new patrols based on their movement types/subtypes centered on their current location, which can make kiting those enemies easier or harder depending on how well adjusted you are to the player's movements and abilities, either intrinsic or toolset based.

When it comes to creature's changes in, say, Swapping out different characters or creatures in certain biomes, either going deeper into the "Thick" of the Biome where it is in Totality versus the concept of if the further from the main environment, you're likely to see lesser factors of what the biome has to offer (usually cut off until toolset is upgraded or adapted appropriately). The deeper in, the more you'd probably find creatures that have hard adapted or evolved symbiotically to the environment and exhibit those factors more so than something that can exist in multiple biomes or those that live closer to the edges. Similarly, you'd still have your general hunter and prey as well as symbiotic relationships within those ecosystems. Like having a sharp spined Antelope that weighs 400lbs and leaps 6 feet, which is completely believable, while also entertaining the idea that a Large Tiger with 3ft claws, paws, and fangs designed to be able to take down the Spiny Antelope, and be the reason why the Spiny Antelope are Spiny.

In that same example, though: You know that the Tiger's Main move set is using it's Grapple with Claws, using a Bite attack, and then while the target is grappled (usually all front claws and teeth to control movement), it rakes it's Rear Claws against it's prey, usually attempting to target sections that are soft. The Antelope, however, you know can leap and ram as well as run over a target. Just based on the Body framing and Body Type.

I know in the example, I didn't mention a Biome, and I could challenge you to close your eyes and imagine these creatures fighting in the wild, and where the wild might be. Most of you might imagine a Jungle or a Savana, and I would wager that both or even a Forest would be befitting, maybe a forest high up in the mountains where instead of a Tiger, it's a more sleeker Mountain Lion where even the claws are more hooked for climbing crags versus the already cloven hooves made for tough climbs the Antelope has. Note: the Two different Feline species fitting the same niche adapted to different environments to hunt the same nomadic species that can co-exist in multiple biomes on the same world in a way that makes sense to those environments and to the world itself in regards to those species.

Now you're envisioning a whole world. Still: That brings the Antelope to 1 to 3 abilities or moves in a move set (Ram, Stomp, Overhead Ram), and the felines to about 3-4 based on their complexity of body type and general feline hunting concepts: Claws, Bite, Rake with the last one exceptionally conditional, requiring the feline to be able to grapple their target on a successful Claw and/or Bite. We've now added an intrinsic or Passive to the Antelope that makes up for the lack of moves but with defense, which may cause damage to the feline while the feline has the Antelope grappled, both adding a bit of simple complexity to the Antelope that ups the ante of risk for the reward, the Antelope meat, to the Feline.

Okay, So we see that on average that maybe setting your critters to have a specific number of moves per move set, like Pokemon using a 4 move move set and Palworld using a 3 move move set that can be interchanged at whimsey, might be a really good idea. But then you're concerned about complexity, that later moves can't be more complex.

Just like movement types and mixing variations of how more complex creatures move with combinations, same goes with move sets. Maybe an Antelope from the Deep Mountains will have a Jumping Ram attack that also moves them horizontally before trying to also throw the target over their own backs, scooping with large curved horns, or if a straight horn variant tries to spear the target and then trying to scrape them off their horns on a successful impalement which includes then some stomps before kicking the enemy away. Either Extended Abilities based on the Base Creature's Body Type, or adapted due to weapon type, and/or Chained conditionals, which could add more risk with timed hits systems.

What about stats? Hard numbers technically don't need to exist, but general Scaling based on either if the creature is a Boss (which should be the max stats for the area per Event status/quest line/Act or whatever arc at least for the first time provided that Boss Monsters aren't reoccurring, or if they are, shouldn't deviate too far from those max stats, obviously adapted to body type, with each section's critters being less or close to those stats. So, Give everything a scale of 0 to 10, 0 being the absolute worst a creature could be in this area bracket, with a 10 being the absolute Best in the area.

If you are going to go the hard number route first, then you need to figure out how much time you want your players on average if they're not going to do anything more than the main quest line to decide on how much character growth you want before introduction to the boss, factor how difficult each lesser battle, how long you want your players to spend in battle (both regular and boss battles) and give each battle a value that contributes to the overall growth that meets or exceeds the section challenge.

Some games, instead of using Stats or raw numbers will lock this behind something along the lines of a weapon or skill only obtainable through a quest line, through the area itself, discovery, or through a currency of some sort that eludes to the solution to the challenge.

Going back, again, to Heuristics and it's importance to game/world design.

This is in addition to the importance of Diegetic systems, and I'm not just talking about systems like you'd see in Dead Space, but things like Monster's Injury states vs having health bars over enemies. Actual changes in their state of being, maybe even limiting Movements due to the total amount of health they have, or maybe one of the characters drinks a potion on a table nearby, and suddenly they've increased in size and can't seem to control how they move with more fits of rage before the effects wear off and limits their movements. If the potion isn't present, Don't do the move, which limits how much complexity due to an environmental factor. Say one enemy bounces off the shield of another enemy, but if the shield enemy doesn't exist, the bouncing enemy wouldn't have access to that move even if it exists in the move set, and even still, you wouldn't want it to happen all the time every time a shield enemy the bouncing enemy can bounce off is present.

Entering the Conversation now is Cooldowns and Attack Patterns, which can be, but aren't, the same things.

Cooldowns in general are always good for helping things decide on what to do in the case of abilities requiring some sort of currency to do. I state Currency, because it is. Magic, Mana, MP, Stamina; Collectively they're nothing more than coins collected in whatever fashion that variable gains from nothing to a speculative or direct maximum capacity at any given time, or else a Wallet for all intents and purposes: A container in which to store a value. It means something has a harder time Spamming or repeating the same action too many times in a row versus creating dynamic move set economy by choosing different most likely options, or (the norm) deciding to spend on the cheapest option off of cooldown (depending on target, target type, and bias towards particular targeting).

Even without Cooldowns; Creating attack patterns, such as stating that: for every 2 regular attacks, this special attack is going to be used instead provided the resources are available else do this instead. We call these things "Conditional Blocks" and can get much more complicated than this simplified version.

It's better to create a more Hybridized format the more complex you make your creatures, but it's also a distinct grand idea to create a limit of moves per move sets, and also limit how many moves that are completely conditional such as the Diegetic examples above. Some mostly for Boss creatures, but as more of the norm with exceptions to the rule in regards to enemy groups and including synergy with those creatures. This either means that due to the presence of those factors, one of two things should happen: Either moves are replaced in the default base move set while those factors are present, or it instead is added with a conditional that adds the move to the move set properly with it's own factor in the overall move set - Meaning Always Present, but only Active When else Pass to next rule/move in the chain.

Mind you this is so that you can create while keeping yourself within a sort of scope and not let monster designs get carried away. In the end, it's your game, right? So do what you want. But keep these things in mind if you have to consider the idea or ideals of creating a balance within your game by sections, treating each part as a vertical slice. Your Core system should be essentially the same across all parts of your game, meaning that each section should in some way mirror any other section just adapted to different challenges to be overcame towards the same central goal.

Too much deviation means that your stakes need to increase well past it's ability to sustain itself. Too many moves and you force your players to need to adapt to too many things. Too many Moves and you force your players to need to see every set of patterns. Too few moves and you risk how dynamic your creatures become.

How do we figure out a monster's Move set?

First, look at the body type and pay attention to it's attributes. Pay attention to natural and un-natural weapons the entity may have. How those attributes are used is part of it's move set.

What if my monster has like 10 weapons or something?

Why would your monster need to have 10 weapons? At the same time? Why in the World would you need that many weapons? Or Even more? How large is this enemy? How many times per turn is this monster making an action? Not even considering rounds.

The other part of Turn Economy within say a turn based or ATB based system is that you need to consider the length of a standard turn within a round, and justify having a large or many part entity in regards to total round time frame, or even the consideration of how long of a total battle you're looking for in general. How well you can hook, capture, and keep the attention of your demographic.

Fight Types and why they're important

Puzzle fights

These require a certain either skill, mix of skills, item present or used, or strategy applied in a certain way in order to successfully complete the fight

Filler fights

The stuff that doesn't mean much but is intended to pad the time of an area, or to grind for materials not necessarily for Stats/EXP/Whatever Currency

Average encounters

The main Party of Enemies you're expected to encounter and level up with that averages the entire area (usually sub-sectioned off to specific locations within the area) as expected through exploring the main quest line path.

Unavoidable encounters

Enemies meant to block off sections into next sections of an area/act, but not as powerful as a Mini Boss or Boss encounter. These are basically just wall encounters, basically.

Mini Boss encounters

Usually Mini Boss Encounters are difficult encounters that signify the midpoint of the section or act. Sometimes they're smaller bosses before the main boss of the area, not limited to being eliminated by the boss encounter interrupting the battle after the players have removed a certain amount of health.

Boss Encounters

The Main Climax battle of the Act or Section before moving on to the next portion of the game, or before the end credits, depending on the length of overall play and when this boss in particular is introduced. The thing is that true progression of Boss Enemies indicates either that the game is required to become excessively more complex the more complex you make each Boss previously, but also the risk and reward needs to scale appropriately to each boss monster or Boss group, depending on the situation.

The thing to also consider is that the more complex you make an entity, the longer it might take before it decides and makes a move. Additionally, the more enemies you pack on the screen, they're in the turn queue in some form or another as to who and what and when it's attacking, meaning in a turn based scenario, you're increasing the length of the battle by having more things that need to make actions per round. This means in order to limit the overall length of a battle, not only turn and move set limits, but also monster and monster summon limits.

Here's some quick math as an example of an average:

If all of your attack/skill/item actions, for brevity moving forward, Actions are 3 seconds long, it means with 4 player characters and 5 monsters, an average round is 3x9 or 27 seconds, or half a minute per round. Not including what gets eliminated, either player or monster, during that round. Add Turn Queue Checks and Transition Time from one entity to the next, so about 1-2 additional seconds. Now we're at average 36 second rounds, and that's not including the time to input information or pay attention to clues around the screen, so now we're already totaling 5 seconds per turn for all turns per round, but additional time to about 9 seconds per turn with human involvement if auto-battle isn't a thing.

(9*4)+(5*5)/60
or 36+25/60
or 1 minute 1 second round

On average, per Easy Battle and considering the menu to be 3 click deep on options.

Things to improve that time is by making enemies easier to kill either through player growth, or considered through default stats. while all players aim for a single round clear, enemies might start off being killable after 2-5 swings or shots of their weapons until progress happens, or in the case of smaller enemies, might be more so filler to slow down your players through sapping health but being single hit enemies, and knowing when it's more acceptable in one area instead of another.

Returning to Ecology and the concept of synergistic ecological systems, biomes that are prevalent of having a plethora of entities would more likely have more filler enemies, where as places that seem more devoid of life or have more hidden life will be less populated and more likely to be designed to survive more harsh environments, such as the Iron Slug that lives among other species in underwater volcanic steam vents at incredible temperatures, an actual creature in our own world in it's environment.

Another example is that while lizards and serpents exist in more lush environments, they're more noticeable in hot desert biomes and environments because of how their bodies retain water and how temperature effects their bodies, being cold blooded. Being more flat and designed to have natural heat sink dissipating excessive heat and utilizing the heat both for basking, metabolism, breeding and incubation, but also their body designs help in creating Moisture from their own skin and naturally funnel it to places they can intake it.

An absolute digression, but as a viewpoint towards figuring out what sort of creatures would best belong within certain environments, and attention to detail as to what and why as well as how they survive and comprise as part of their ecosystem. Bison and Buffalo, prevalent in the plains of the United States at one point, Camels don't share the curled tufted hair for the wet and cold instead opting for a thin flat hair to combat the heat.

So, Now I've introduced the differences between different environments, and how changes in those environments help create those diverse fields while technically fitting similar niches, at least in the comparison between the Brahmin and the Dromedary creatures, while showing the concept of real world adaptations to adverse environments.

So, other than environment, and how those creatures are surviving in the environments, and body characteristics, another rule of thumb when it comes to creating move sets and moves for those move sets is setting up a general list of move types.

I mentioned a couple of Ram moves and stomp moves

A Ram move would be something along the lines of direct line of sight attacks, or Kinetic attacks (in some cases) if you decide to have a lot of different Ram-like Attacks. These basically are A to B, and usually is either stop at whatever is in the way and do an action, moves through all objects/obstacles/targets within that line between A to B, or chooses a new target when reaching B up to a certain amount of times.

Line Attacks, basically

Area attacks generally effect everything within a certain area, and you can decide the shape or Shapes of the target area.

Spheres/Circles
Good options for this is Grenades or other splash attack like attacks and all radian based attacks that has a central effect activation position
Cube/Squares
Great options for trap and trap-like effects where the move plants the trap, and there's an area of effect, though Sphere and Circles are great options for this. Though Rectangular and long areas are effective for showing, say, lines of rocket fire across a battlefield. Sometimes called Row and/or Column attacks where an attack does damage within a specific zone including targets within a certain number of spots on a board or battlefield, or just adjacent to center position targeting based on row and column stratagem

Direct Touch attacks involve the character actually going to the target and does an action directly to that target, like the Stomp example where one of our Antelope will just rush up to the target, rear back, and then slam down with their front hooves using all of their body weight they can in order to cause damage and possible disorientation, depending on the system (on hit chance, % rate of possible status of stasis or stun or confusion).

And then there's Ranged, or Projectile Attacks. Those can have multiple things going for them, not only the fact that they're attacking at a distance, or the backline, or hidden behind some cover. The Projectile could be modified either by what it's fired from, What it does when it strikes something or if it might explode after a certain amount of time with all of the Area of effect effects added to the projectile damage, as well as possible other additions such as elemental or status effects to those projectiles.

Those same Elemental or status effects could also be applied in some way to all of the other attacks.

That's About 4, arguably 5, moves with possibly variations and numerous ways of displaying those moves. This is including the concept of using items in battle. Adding a Defensive position, with or without a buff, is an additional 6th possible move.

And you can mix and match them.

Just remember how long you need to keep the battles to ensure that you're maximizing the amount of time you want your players to take in your battles to match your progression style and speed. The Mandatory Minimum amount of battles to complete the entire area/arc/act/game.

Log Viewer for Streamer.bot

Trabin — Wed, 16 Jul 2025 22:03:24 +0000

🎮 Streamer.bot Log Viewer — Real-Time Log Monitoring for Streamers

A Windows Forms companion app that streams logs from your Streamer.bot setup live—complete with filters, alerts, pinning, profiles, and more.

🧩 Why This Exists

If you're using Streamer.bot, you've probably noticed that keeping an eye on logs (errors, warnings, events) while live streaming can be a hassle. That’s where the Log Viewer comes in: a dedicated Windows app that hooks into Streamer.bot/data/logs/ to provide a sleek, real-time log display with powerful filtering, alerting, and organization features.

🗂️ Folder Setup

To get started, make sure you drop the Log Viewer files into your Streamer.bot apps folder like this:

 Streamer.bot/
 ├── data/
 │   └── logs/
 └── apps/
     └── Log Viewer/
         ├── StreamerBotLogViewer.exe
         ├── StreamerBotLogViewer.dll
         ├── logviewer.jpg    ← splash screen
         └── (other dependencies)

This structure lets the app automatically detect logs and show them live.

🚀 Automatic Launch on Streamer.bot Startup

Forget manually opening it each time. Auto-launch Log Viewer right when your Streamer.bot starts:

Open Streamer.bot.
Go to Actions → New Action.
Name it something like “Start Log Viewer”.
Add a new Sub-Action:
- 1. Choose: Core → System → Run A Program
- 2. Type: Execute Program
- 3. Path: apps\Log Viewer\StreamerBotLogViewer.exe
- 4. Working directory: apps\Log Viewer
Set the Trigger to: Core → Streamer.bot Started

Or just import this

U0JBRR+LCAAAAAAABACNVU1zmzAQvWcm/4HhXDEG4wC5pW2SHnroJBlfSg4LWogmIFEhbGcy/u+V+LDBOG2O2vf0VrtvWd4vLyzLLlGBfW29m4M+cihRH+1HBVJZP0VuPSBQlPaXngCNehHSUJ5e8ElCwvgB26CsmeAGdJ2FszgAFOtUskr1YCteW4Jbj1+tQgAdq4uHht+kPZU3RTFgJeOsbMr1IYkBDbZvGTaFSSXQatQ68ruLWAPUwoyalyQI3jLMIpJ4rkd8iAKSrDIglHqQLiFMAj8bHtde+9Ngg9OHtXHkkBRoNJVscILs0qKheCdF+YPVSsg3TcqgqD9i/UJOGc/Psf7nTkvKpWgqw7qhumUWsW43yJVRHLOg2MJbrXt9Lo8ETkV5cGGGp4KnjZRa9hyqJMtz7dK49SftH1ngL9DNAt8j3ioIiL/yQhJChARpFLmpH4RhOLGgS/FWmUYEi6tT5EMjjm2uh7l4HqP74+F50qj5HJ0rJhVlqbtmKrq/juNaSYQyEcqNY6iqOo6NW2uGW5RxrMf+aJ6DO5wVCDJvSt1fk9eeoVshX7Wh35n8TL7ZdeSbNbT+vO9n0sDUnZC3O2a8XZzCnWfR8irLkjQkmRdmxI9oQGAZpSQK3WzpJmmCq3lJW2T5SyvqzGR7P2duDrN88rn1VfzLacYp7kyyz3t8b5J1gzEd9qKAqkY6wge4Fxz43XqYSAyDMQ1uMalF+orqEeWm/1Tm4LeC9SNwBBUrB/5o9x03r+t2EdxVQiqkZqMYyxaO54SdJ/NN2qI+SfS/wLmyLy/2fwFvot39HAYAAA==

Let it run itself, hassle-free.

✨ What’s New – Latest Enhancements

Jump to latest post — Instantly scroll to the newest log entries.
Larger buttons — See labels clearly at a glance.
Faster load times — The app now starts up much more quickly.
Caching & position memory — Retains log position and filters across sessions.
Pause on scroll for Auto‑Scroll — Stops auto-scrolling when you scroll manually.
Context menu — Right-click log entries to:
- Copy selected text (all highlighted)
- Copy a single line
- Set text as a Keyword and auto-jump to the next
- Set text as a Keyword Alert
- Set text as a Filter
Improved profiles UI — Profiles dropdown relocated to the bottom along with its label, making it much closer to the “Apply Filter” and “Save Profile” buttons.

🛠️ Core Features

🔍 Live Log Streaming — reads from Streamer.bot/data/logs/ in real-time
🧰 Filters — by text, regex, warnings, or errors
🚨 Alerts & Keywords — define alert words and tag them with profiles
✍️ Pinning — mark important lines and export them later
📂 Profiles — save/load filter/keyword sets for different stream setups
⬆️ Scroll Control — auto-scroll or freeze scroll to review logs
🔍 Jump to Keyword — instant-find key entries
🧩 GUI Tools — tray icon, minimize/hide functionality
🎨 Splash Screen Support — place a logviewer.jpg file to customize startup visuals

⚙️ Requirements

Platform: Windows (with Streamer.bot installed)
Runtime: .NET 6+ (unless use-shared runtime binary)
Include logviewer.jpg in the same folder as the .exe or accept default splash behavior

💻 Getting Started

Drop the Log Viewer folder into Streamer.bot/apps/
Add the "Start Log Viewer" action in Streamer.bot.
Launch Streamer.bot—Log Viewer will spring to life next to your logs.
Customize filters, alerts, and profiles to suit your stream setup.

📝 Developer Notes

Multiprofile support lets you switch quickly between different filter/alert setups
Pinned logs give you persistence during a long stream—for post-stream analysis
Splash-screen image is optional—but recommended for branding
Built in .NET 6 (Windows Forms) for familiar UI and minimal overhead

🧑‍💻 Who Made This?

TheTrabin (@Cobalt Rogues), 2025 — part of the Cobalt Rogues development series.

Clicking name will go to Https://trabin.space, home of Ashworn

⚡ The Final Word
The Streamer.bot Log Viewer bridges the gap between raw logs and actionable insights—live. If you're building a modern stream with automation, widgets, chat commands, and more, this app gives you real-time control over your log output. No more endless scrolling or missed errors—just clear, focused monitoring.

Yo, First Game Jam Completed Game done.

Trabin — Sat, 27 May 2023 20:12:31 +0000

Itch.io : Trabin/Wry-Pin
GD Games : Trabin/Wry-Pin

It's made in GDevelop, which I'd hadn't touched prior to this past week. Also, using an Experimental Extension that allows 3D space, which has little to no documentation.

This was actually a whole lot of fun. If it gathers enough interest, I'll expand it, focus on art and fine tune some stuff.

GDevelop dotes itself as a Code-free game engine, though there is a lot of logic involved. It is pretty quick to get going with it, and there's a myriad of various in-engine tutorials and examples that helped out incredibly. I don't think I would have picked up on it as fast if it hadn't, and the learning curve compared to Unreal (which has also become dev EZ mode) and Unity is much much smaller.

GDevelop allows you to also not only develop locally, but there's a free cloud service that can hold onto your games while you go from one location to the other, but also On the Go. GDevelop works in app and in browser, meaning you could be working or fixing a game while on vacation or while riding the bus to the convention. From simple to complex, GDevelop might not have the power of the bigger names, but it does pack the kit well, and more and more possibilities are becoming a reality with this engine.

If this is something you're interested, this is what I could do with no experience. Imagine what you can make?

I'd love to see what you build.

Did I mention that GDevelop is Free and Open source?

An Abridged Guide to Working with Teams

Trabin — Thu, 29 Apr 2021 22:37:26 +0000

Welcome! I've had a wonderful opportunity to work with some amazing people in Lambda Labs, after working hard and long at learning what I could from Lambda School's Full-Stack Web Development course.

In this post, I'll give you a semi-short rundown and some good practices that I learned that you can apply to just about any project and how to work with a team to get things off the ground and have great experiences along the way. To make it easier, I'll set up a Table of Contents, and at the bottom of each section a way you can jump back up. Easy as cake.

Setting the Stage
- Introduction to your Organization
- Tools of the Trade
- Planning
- Contracts
- Roles
Learning your Lines
- Laying out the framework
- Drafting the Basics
- Set Design and Environment
Act 1
- Installing your project requirements
- Getting your externals working correctly
- Debugging and fixing errors
Intermission
- Additional Brainstorming and Refactoring
Act 2
- The Actual Code
- Deploying
Epilogue
- Documentation
- The Sequel

Setting the Stage

Introduction to your Organization

Your Organization is the key reason as to why you are developing your application, and who actually owns the application. They may have specific rules as to what you can use, how you implement what you're allowed to use, and how you go about reporting your progress to be tracked. Often there are stakeholders who have invested in the project who will want to know how you're putting things together and your progress in how it is working or if it's even working and a timeline of events and staging. Like Release Candidates or versions of the application, and what you might need (within proper reasoning) to move the project forward.

top

Tools of the trade

So, you're going to need specific tools to make your project. For woodworking, you'll probably use actual tools like screwdrivers, hammers, sanders, nails, and anything to put it all together. In the case for programming: We're looking at things like Packages that you'd install into the application to make it work.

In the case of this project, a lot of the decisions and tools were already established by the Organization we were working with, which I'll go over a bit later. The packages at least for the Web development side were React.js, Axios, Heroku, AWS, Okta Authentication, Express.js, Knex.js, Redux for state management, Node.js, and Node Package Manager for installation. Docker was also a choice given for local hosting of the web database for testing and virtual machine hosting.

Then there's Whimsical, which has several uses. Below, we used Whimsical as a visual guide, a breakdown of what the application roadmap would look like and how things would connect when the application is complete, the status of how it works, etc.

^{*The A-Team's Wonderful Whimsical Board!}

^{Our Mapping and Flow chart}

Trello is a big option for the flow of communication, as well as a visual guide via cards to explain what has been done, what is in the process of being done. Below is an example of a Trello board.

^{The A-Team's Trello Board}

Also, here, and example of a Trello Card which includes links to Pull Requests hosted on GitHub and checklists on what has been done on a particular task.

^{An Example of a Trello Card}

GitHub was the Version Control and code storage method chosen, though your Organization might have different options.

^{Our Organization's GitHub}
^{Our Repositories}

top

Planning

Any good project starts off with a Plan, like what you're making, how you're making it, and the process in which that you go about doing it. This isn't exactly just for programming, and it applies to just about any project. An outline of your goals, what tools you need to accomplish said goals, and how you plan on having it presented. In this case, we're going to cover an experience I had working with a great team attempting to build off an application designed to present information for Cities.

In the case of our project, we took what goals we were given and set out to look them over in a way in which who ever might be using our application might best want to work with it by making User Stories.

As an example: As a User, I would like to save Cities to resume researching later.

top

Contracts

So, What do I mean by a Contract? A Contract is more so a Promise, or an outline of what it is, such as a database endpoint, in which something is agreed upon by your group. As long as it's something your team can connect to, work with, and returns with the promised information, that contract will be fulfilled. These are important for the flow and communication within your team.

^{A Display of our contracts for our Team's endpoints}

top

Roles

Your team is going to either be big or small, but no matter the size, everyone is going to have a role to keep.

My team comprised of 5 web developers including myself, 3 Data Scientists, 1 iOS developer, and our Team Project Lead.

Within that composition, our web developers were broken into 4 Front-end developers that took care of various things, 2 of which were design leads, and 1 Back-end developer, which is the responsibility that I took charge of.

Your mileage may vary, both in size and ability. Just try your best to be as patient as you can with your team, and hope they're also patient with you.

top

Learn your Lines

Laying out the framework

So, you've got your plan. You know what tools you're going to use. You have everything together, know your role and what part of the grand plan you're in charge and responsible for. You might be working from scratch, or be working with someone else's code (more likely the latter). What's the next step?

You're going to want to lay out what you're doing and in what order. Such as building a basic frame to hold the code you are going to implement. That could even be specific modules that you've named.

top

Drafting the Basics

Getting a good idea of what you're doing based on your experience and research, then actually writing it out on something like a piece of paper, or in a text file separate from your project so you can refer to it is a good plan. Even if it's not active in an IDE, it helps you form a basis as to what you're building and putting together. Just like the planning stage, this is where you break each individual thing out like making a map and gets it moving in your brain.

Break each problem down. First start with a main goal, an outline of what it is that you need in order to reach that goal, and then write out cases, from most common to least common (or edge cases). This can take a bit of time if you've never done this before, but it really lays out what it is you're going to do and how to get it going.

Even in programming: Measure twice, cut once. This ideology helps reduce errors, and builds better applications. If you have to research something, getting as much information about something before you start reduces problems and helps you fix the bugs when they do turn up.

top

Set Design and Environment

You're going to have basically 3 key environments: Development, Production, and Testing.

Development is where you write your code out and work most of the bugs you can find right away.

Production is what is launched, or known as your deliverable. Your project in a released state.

Testing is exactly what's on the box. This is what you run when you're doing automated testing, which is code that acts like the user.

top

Act 1

Installing your project requirements

Alright, you've got yourself a framework, you know what you're using, you're ready to get started installing your stuff.

You've got your IDE setup, you're getting your packages installed that have been decided on with your team as to what you're using. Awesome. This is probably going to be a lengthy part of the project, because you have to make sure that your packages install with the right version to get everything to work, and each package has it's dependent packages installed.

Awesome. You've got this part in the bag.

Well, Let's go back to that project I was talking about. One of the biggest problems I had was getting Docker to function correctly. I had a myriad of different issues, starting with the fact that Docker being a Virtual Machine emulator, I had VMWare (another Virtual Machine Emulator) installed with Vagrant. Docker then decided that that was the moment in which My PC (running windows) would become unstable. Frequent false starts, wouldn't boot up into windows fully, I/O errors.

So, I uninstalled Vagrant and VMWare thinking that would fix the issue.

That was a big fat nope.

Okay, So I uninstalled Docker, let someone know that it wasn't functioning as intended, and then I was let in on something new, or at least new to me.

So, I had set up WSL2 a while ago when I was playing around with Vagrant months and months ago so I could see if I could get Ubuntu running in the background. At the time, there wasn't any actual kernels to install to get it going very well, so installing some packages were moot. What I didn't know was months later, someone wrote an official kernel and I didn't have that installed. So, I went through and checked via PowerShell that WSL2 was in fact installed (which it was), then installed the Kernel. After that, I installed Docker and Voila! Test Repo went through, and that allowed me to punch forward with a now stable machine. Awesome.

Remember, folks. Measure Twice.

top

Getting your externals working correctly

That's a curious phrase, right? Well, not really. So you're going to have to deal with a few things like Hosting. That could be AWS, or Heroku, or Elastic Beanstalk. With those kinds of things, you need the right variables to ensure that whatever it is that you're going to launch the product on is available to you: You have to gather your resources and put them where they're secure and accessible by your application, or group of applications that talk to each other. This could be environment variables, could be log-in information, could be a bunch of things.

You'll decide with your team, or your Organization will give you what you need, in order to get those things up and going in preparation. It might be that your application is already hosted. That might save you time, but being able to affect those things and connect with them is very important. Don't forget last minute.

top

Debugging and fixing errors

This part is going to probably be ongoing, but it's just as important as the rest. No matter how good you are at measuring, you'll probably mis-cut at some point. That's fine. Things happen. It's how you handle it when it does happen. This is where you're going to have to keep your cool and track things down.

So, something I learned when your web application isn't exactly stable is learning how to read the errors. Some might be general, some might be explicit, and then there's tests that might run to ensure that your best practices are being generated properly.

I came across some variable errors while attempting to launch to Heroku. First, I was getting a error code 1, which is super general. I updated the information to allow a recent version of Node.js, which fixed the error, but it could have been a ton of things. Do a bit of research on the error to find a solution.

Another error one of my compatriots came across involved a module not working correctly. So, we went through and turned every import to explicit de-structuring, which isn't going to solve the problem, but what it did do was layer down to the root cause of the main error as to why it wasn't importing properly. After fixing the root error, we removed the de-structuring and it cleared up the issue and the application was running properly.

top

Intermission

Additional Brainstorming and Refactoring

So once you get your code working, it might look like a huge mess. Refactoring is important as it helps clean up the code for readability. The easier the code is to read and to track, the better it is in case you need to get into it and especially if someone else is going to dig in themselves. Chances are someone else is going to read your code and work off what you've got there, while still doing their best to maintain what it is you wrote.

What else is cool is if you have a particular feature you want to make work better. Getting those lines down without compromising the functionality of your code will not only streamline the process, but reduce the amount of space allowing more room for more things within possible limited storage. Web pages and applications are getting beefier, and the less storage you take up and use smaller scripts to increase the load of a program/application, more likely you'll be able to not only track bugs down to a specific module instead of looking through a sea of code, but the better the readability is going to be. You'll know where things are, and how they're stored.

Also, More features != better. You want to make sure that while you're adding things to the application, the more you have things built into it, the more cluttered it can get, not only with code because you have to be aware of things like side effects such as one feature interfering with another feature, but also just the amount of options can be overwhelming to a user if it's not implemented where it's intuitive to the user. Think less like an engineer in that respect, and think like the User. Lots of options can be great, but make sure they work off of each other.

top

Act 2

The Actual Code

Alright. You've got your plan, your frameworks made, you've prepped for the most common bugs, you've kept everyone in the loop, you've got everything you need installed. Here comes the fun part: Code. Write it out to the best of your ability, and even do your best to go above and beyond what you've learned previously and make the most of it. That's really all there is to this part. Just pay attention to how your code displays. If you're requested to use a linter, cherish it. It'll help you out immensely, but also make sure to do your best to write it all out without having to rely on copy-pasta or autofill. Think of those things more so as suggestions, and it's more likely those suggestions might actually lead you astray, while on the occasion, they can help you (like getting those pesky imports to function properly). Toss some music on that inspires you and go deep in.

Make sure you document your Pull Requests with what you've done. You might have a template to follow via your Organization, or you might not. If you don't, Make sure you build one out so that you and your reviewers can identify what it is you're adding or editing and want to merge into the main project. It's always good to have a couple sets of eyes on something in case you miss something or it's just not working like it should. Keep the conversation going, and if you're reviewing someone else's code, do the same. Don't take it too personal and be patient with the process, and know that someone might not get to yours as quickly as you'd like. It's going to be alright. Just reiterating: Keep the conversation going.

top

Deploying

Now you've written your code, you've debugged, you've let your team know what's up, and it's time to punch it up to the server with a working deploy. You've done it.

From there, if there's more features you need to add, you get to start the process over from planning, the framework, making sure your dependencies are set up properly, and then diving right into the code before requesting it to be pulled into the main code. Rinse and Repeat.

top

Epilogue

Documentation

Documentation is super important. I can't stress this enough. When I got into my project, it was a build-on that didn't really have a lot of documentation as to what was already written, and it took a bit to explore what it was that I needed and what was or wasn't already built out. I'm not saying write out a full blown wiki, but something along the lines of informing of what else needs to be done, or what has been done, is a good idea in order to get the next person moving a lot faster into the code. Also, making sure that your pull requests have enough information to go off of is excellent. The next person that looks at your code and reviews the documentation can get what they need installed in order to get the project going and hit the ground running.

This is also good for any project, not only the ones you work on with a team. A thing to remember, though: Not everyone is going to be at the same skill level. There might be people who have a natural knack for programming, and some people might be struggling with it but are making at least a real effort to get things going. Making sure that your documentation is clear enough for both ends of the scale is not only best practice, it's the cool thing to do. I know I could do a lot better at that, and am making large strides to doing a better job at it.

top

The Sequel - What the Future holds

So, this blog post is most definitely the first of many, and don't think I'm hanging my hat on this stand: There's going to be a lot more working with Teams, Solo projects with breakdowns on how I got them going, and a lot more. The first of many.

top