Trimdu

trimdu

Autonomous AI systems are intelligent computer programs that can autonomously perform tasks and make decisions without human intervention or guidance. The development of efficient autonomous AI systems presents challenges due to biases, ethical considerations, transparency, security, and control. In this article, we explore the theoretical G.O.D. (Generator, Operator, Destroyer) framework inspired by mythology as a way to build an system that revolutionizes our lives through a balanced approach to problem-solving and decision-making. autonomous AI The G.O.D. framework echoes the , consisting of Brahma, Vishnu, and Shiva — the Generator, Operator, and Destroyer forces, respectively. In the G.O.D. framework, three AI models have unique roles and responsibilities: the Generator AI model creates tasks based on a goal, the Operator AI model executes tasks autonomously and efficiently, and the Destroyer AI model monitors progress and takes corrective actions. Hindu Trimurti The Workflow of the G.O.D. Framework in Autonomous AI Systems Define the goal: A human user defines the AI system’s goal. Generate tasks: The Generator creates clear and unambiguous tasks aligned with the system’s goal. Operator execute tasks: The Operator autonomously and efficiently executes tasks, potentially replicating itself to perform tasks in parallel. Destroyer tasks: The Destroyer monitors task progress and takes corrective actions to refine/ purge tasks and ensure the system works towards the desired outcome. Feedback communication and coordination: The Destroyer refines tasks and ensures the system works towards the desired outcome. Teacher tasks: Embodying the spirit of Lord Dattatreya, the Guru of all G.O.D.s in Hindu tradition, the Teacher model represents the importance of continuous learning and improvement. The Teacher model learns from experiences and adjusts the other three models’ roles accordingly. Additionally, it checks for patterns of unethical goals/ task creation and controls it. Implementing the G.O.D. framework Generator AI model: The Generator AI model uses techniques such as natural language processing, machine learning, and deep learning to create specific tasks based on the human user’s defined goal. Leveraging recent developments in Large Language Models (LLMs) like GPT-4, the Generator model can be deployed as a serverless function on public cloud platforms, triggered when a goal message appears from the user or the Destroyer model requests task refinement/removal. Operator AI model: The Operator AI model executes tasks generated by the Generator AI model autonomously and efficiently, using techniques such as robotics, computer vision, and natural language generation. With access to vast internet data, the Operator model can also be deployed as a scalable serverless function, triggered by messages in the task queue. LLMs like GPT-4 can be utilized for tasks that involve text outputs or can be described in the text. Destroyer AI model: The Destroyer AI model monitors task progress and takes corrective actions to refine tasks and ensure the system works toward the desired outcome. It employs techniques such as reinforcement learning, anomaly detection, and decision-making algorithms for continuous improvement and refinement. Serverless functions and models like GPT-4 can be considered for deployment and processing to avoid building custom models. Teacher AI model: The Teacher model monitors the performance of the other three models (Generator, Operator, and Destroyer) and provides corrective actions to prevent repetitive loops and ensure ethical alignment with guidelines and goals. The Teacher model should be trained on a large amount of data covering a broad range of scenarios and use cases. Existing tools like OpenAI moderation endpoints can be useful for part of it, and can save on model training costs. Example goal: We will understand this with an example. We will use GPT models to deliver this example goal. Benefits of the proposed approach : The G.O.D. framework offers a straightforward and easy-to-implement approach for ethical AI, leveraging successful Simplicity LLMs. : The framework balances the four models (Generator, Operator, Destroyer, and Teacher), enabling the AI system to continuously learn and improve without entering repetitive loops or unethical behavior. Balanced roles : The G.O.D. framework emphasizes ethical decision-making and goal-setting, helping to prevent harmful or unethical behaviors. Ethical decision-making : The presence of Lord Dattatreya and the Teacher model emphasize continuous learning and improvement, aiding the system’s adaptability to changing circumstances. Continuous learning : The G.O.D. framework is designed for flexibility, with the Generator, Operator, and Destroyer models allowing for quick adjustments to goals and tasks as needed. Flexibility : By emphasizing goal-setting and task optimization, the G.O.D. framework may enhance the overall performance of the autonomous system, leading to better user outcomes. Improved performance Limitations : Implementing the G.O.D. framework with custom models requires expertise in AI, ethics, and other domains. Complexity The G.O.D. framework involves multiple AI models, potentially requiring significant computational resources, leading to high costs and slower processing times. Computational Requirements: Despite the G.O.D. framework’s aim to prevent unethical behavior, AI models may exhibit ethical bias due to data biases or subjective interpretations of ethical values. Ethical Bias: The G.O.D. framework may work well in specific domains but may not generalize well to other domains, limiting its broader applicability. Limited Generalization: The G.O.D. framework may not be flexible enough to adapt to changing situations or unexpected events, potentially limiting its ability to make appropriate decisions in complex scenarios. Limited Flexibility: Conclusion The G.O.D. framework provides a simple yet effective approach to implementing ethical AI systems. Incorporating the four models of Generator, Operator, Destroyer, and Teacher, the system is designed to balance between achieving goals and avoiding unethical behavior. The presence of the teacher model represents the importance of continuous learning and improvement in the system. While there are limitations and challenges to implementing any autonomous AI system, the G.O.D. framework offers comparative benefits over similar systems and is a step towards building more responsible and ethical AI systems. Disclaimer: The G.O.D. framework uses Hindu mythology deities as a symbol of different roles involved in a balanced system. However, it is important to note that the framework is not intended to promote or hurt the sentiments of any specific religion or belief system. It is simply a framework proposed to address the various issues faced with the development and deployment of AI systems. References Hindu mythology: Various Puranas- Brahma Purana, Vishnu Purana, Shiva Purana, Avadhut Gita This framework developed by @yoheinakajima also proposes creation, prioritisation, and execution agents with memory.
European Commission. (2021). White Paper on Artificial Intelligence: a European Approach to excellence and Trust. Retrieved from . https://github.com/yoheinakajima/babyagi: https://ec.europa.eu/info/publications/white-paper-artificial-intelligence-european-approach-excellence-and-trust_en

The G.O.D. Framework: A Balanced Approach to Building Autonomous AI Systems

and its own language Rego are rich in opportunities and at the same time easy to learn. However, sometimes realities start to demand more and more as the project grows and developers need to design solutions. Fortunately, Rego allows us to create and now I’ll tell you how to do it by live example. Open Policy Agent custom built-in functions I’ve been implementing OPA for authorization clients in the API. It was required, based on the user’s association with groups (teams, units, etc.), to allow or not some action (in reality, much more factors were involved in politics, but this is irrelevant to the current topic). So let’s say we have some kind of group structure and users that can be in more than one group at a time. And the groups themselves also have relations "many-to-many". As you can see, one of the developers is a member of two teams at once. He initially worked for the billing team, but had the devops skills and wanted to grow as a devops engineer. There is also a SWAT team that is designed to put out fires and help other teams to remove the required volumes in the right time, so it is part of two other groups. And there are two actions in the system: cordon - cordon node deploy - deploy the application in the production Actions are group-bound and also apply to all child groups. . The task is to write a rule for the OPA The solution first requires an org structure in format to be used in rego rules. About this: json {
    "users": [
        {
            "id": "oliver",
            "groups": ["billing"]
        },
        {
            "id": "liam",
            "groups": ["swat"]
        },
    ],
    "groups": [
        {
            "id": "infra",
            "parent": []
        },
        {
            "id": "devops",
            "parent": ["infra"]
        },
        {
            "id": "admin",
            "parent": ["infra"]
        },
        {
            "id": "dev",
            "parent": []
        },
        {
            "id": "search",
            "parent": ["dev"]
        },
        {
            "id": "billing",
            "parent": ["dev"]
        },
        {
            "id": "swat",
            "parent": ["infra", "billing"]
        },
    ],
} Since the rules are assigned to groups, it is enough to check whether the user is in the desired group or not. And whether a user group is a subgroup of another group (at any level of nesting). This is where the problem arose. If recursion is done on Rego (I’m not sure it is possible), then readability will be terrible. There are no ready-made functions either. But luckily there is a possibility to extend Rego with its functions. Here is the implementation of the custom function itself: // search all group parents
func RegoGroupParentsFunction() func(*rego.Rego) {
	return rego.Function2(&rego.Function{
		Name: "group_parents",
		Decl: types.NewFunction(types.Args(types.S, types.A), types.A),
	},
		func(bctx rego.BuiltinContext, groupID, groupsData *ast.Term) (*ast.Term, error) {
			groups := []Group{}
			if err := json.Unmarshal([]byte(groupsData.Value.String()), &groups); err != nil {
				return nil, fmt.Errorf("unmarshal rego groups data: %v", err)
			}

			mappedGroups := map[string]*Group{}
			for k, group := range groups {
				mappedGroups[group.ID] = &groups[k]
			}

			gID := trimDoubleQuotes(groupID.Value.String())
			parentGroups := []*Group{}
			SearchParentsRecursive(gID, mappedGroups, &parentGroups)

			values := []*ast.Term{}
			for _, v := range parentGroups {
				val, err := ast.InterfaceToValue(v)
				if err != nil {
					return nil, fmt.Errorf("convert group to rego value: %v", err)
				}
				values = append(values, ast.NewTerm(val))
			}

			return ast.ArrayTerm(values...), nil
		})
}

func SearchParentsRecursive(groupID string, groups map[string]*Group, result *[]*Group) {
	group, ok := groups[groupID]
	if !ok {
		return
	}
	if len(group.Parents) == 0 {
		return
	}
	for _, parentID := range group.Parents {
		parentGroup, ok := groups[parentID]
		if !ok {
			continue
		}
		SearchParentsRecursive(parentID, groups, result)
		*result = append(*result, parentGroup)
	}
} I can describe what’s going on here: return rego.Function2(&rego.Function{
		Name: "group_parents",
		Decl: types.NewFunction(types.Args(types.S, types.A), types.A),
	},
		func(bctx rego.BuiltinContext, groupID, groupsData *ast.Term) (*ast.Term, error) { A new function is defined, and has two arguments: the group id that you are looking for and the group structure described above. Accordingly for rego functions with three arguments there is a function , with four , etc. group_parents Function3 Function4 Next, parse json with the structure and search recursively for all parents takes place. Difficulties arise when the result is returned, because opa-sdk interface is not very obvious. values := []*ast.Term{}
for _, v := range parentGroups {
	val, err := ast.InterfaceToValue(v)
	if err != nil {
		return nil, fmt.Errorf("convert group to rego value: %v", err)
	}
	values = append(values, ast.NewTerm(val))
}

return ast.ArrayTerm(values...), nil The function must return an array with all parent groups to go through the rules themselves. Therefore, we return . This is an array of rego values ( ) that must be previously created with . Before that you will also need to convert string values from the id of the . ast.ArrayTerm Term ast.NewTerm ast.InterfaceToValue Now is available in rego policies. I’ll show you how it works: group_parents package group_search

import future.keywords.in

default parent_groups_is_ok = false

# Проверяем что группа SWAT состоит во всех вышестоящих группах billing и devops
parent_groups_is_ok {
   groups := group_parents("swat", data.groups)

   groups[0].name == "billing"
   groups[1].name == "devops"
}

# Убеждаемся что в лишних группах swat нет
parent_groups_not_exists {
   groups := group_parents("swat", data.groups)
   groups[_].name != "search"
} Now I can test: func TestGroupParentsOk(t *testing.T) {
   query, err := rego.New(
      rego.Query("data.group_search.parent_groups_is_ok"),
      RegoGroupParentsFunction()
      rego.LoadBundle("testdata"),
   ).PrepareForEval(context.Background())
   if err != nil {
      t.Fatalf("prepare rego query: %v", err)
   }

   resultSet, err := query.Eval(context.Background())
   if err != nil {
      t.Fatalf("eval rego query: %v", err)
   }

   if len(resultSet) == 0 {
      t.Error("undefined result")
   }

   assert.True(t, resultSet.Allowed())
}

func TestGroupParentsNotExist(t *testing.T) {
   query, err := rego.New(
      rego.Query("data.group_search.runtime_parent_groups_not_exists"),
      RegoGroupParentsFunction(),
      rego.LoadBundl("testdata"),
   ).PrepareForEval(context.Background())
   if err != nil {
      t.Fatalf("prepare rego query: %v", err)
   }

   resultSet, err := query.Eval(context.Background())
   if err != nil {
      t.Fatalf("eval rego query: %v", err)
   }

   if len(resultSet) == 0 {
      t.Error("undefined result")
   }

   assert.True(t, resultSet.Allowed())
} Thus it is possible to extend the rego as much as you need. For example, add work with some external sources: databases, headlines, etc. Or how in my case to implement complex logic.

Custom Rego Function by Example

How I make a simple interactive shell in Golang “command computer keyboard key” by on Hannah Joshua Unsplash So today, I learn something new and a bit of basic thing in Golang. It was making a simple interactive shell. It was just a very simple application, but it kinda looks cool to make it. I’ve been working over 1 year in Golang. So many tools already created by people out there, for example: cobra by , or many more that help us to make command line application. But, somehow I’m curious how to make a simple one without having dependencies with other external libraries. spf13 So just out of curiosity, I start to search how to make it in Google. But what I found is only tutorial using other external dependencies. Everyone is only promoting their own library to ease making an interactive shell 😌. Guys? I just need to make a simple one with the pure Golang package (No external dependencies)😌 But, I found an article about making an interactive shell, like this article: , but, what he does is not like I want. So later with only many examples that I found from websites like Gobyexample.com, etc. http://technosophos.com/2014/07/11/start-an-interactive-shell-from-within-go.html I made a simple Shell application by myself. Here I will explain how I made it below. Shell So before making a simple Shell application, I want to make sure that what I mean shell is the same as what you mean. For me, Shell is an application that will act as the very basic user interface (text-based interface). Some people might say it Command Line Interface (CLI). Making The Application To make the application, for the simplest prototype I will make it like this. $ . main. ls <br> go mod go Read the Command from Terminal To make this, the first thing to do is reading the input. I need to read the input from the terminal. To that, I make it like this. reader := bufio.NewReader(os.Stdin)
cmdString, := reader.ReadString( ) err != nil {
 fmt.Fprintln(os.Stderr, err)
} err '\n' if Execute the Command Then execute the command. After reading the command string from the terminal, now execute the command. cmdString = strings.TrimSuffix(cmdString, )
cmd := exec.Command(commandString)
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
cmd.Run() "\n" Until here, now I can run my simple shell application, but it will only run for one command. After running a command, it will stop. Adding the Infinite Loop To make it receive every command after executed once. We need to add it to an infinite loop. {
 fmt.Print( )
 cmdString, := reader.ReadString( ) err != nil {
  fmt.Fprintln(os.Stderr, err)
 }
cmdString = strings.TrimSuffix(cmdString, )
cmd := exec.Command(cmdString)
 cmd.Stderr = os.Stderr
 cmd.Stdout = os.Stdout
 err = cmd.Run() err != nil {
  fmt.Fprintln(os.Stderr, err)
 }
} for "$ " err '\n' if "\n" if If we run the application it will look like this below simple shell application Dealing with the Arguments Until this line, I’ve finished my first CLI application. But it still doesn’t accept arguments. If I pass an argument, then it will throw an error. $ -lah this wil throw error ls // command To read the arguments, I make it like this below. First I split the command into an array of string. cmdString = strings.TrimSuffix(cmdString, )
arrCommandStr := strings.Fields(cmdString)
cmd := exec.Command(arrCommandStr[ ], arrCommandStr[ :]...) // ... "\n" 0 1 // ... For splitting the text, I use the Fields function from package string. This function is similar to the split string function. If string.Split will split the string by given specific separator. But strings.Fields will separate the words by whitespace. Example: str := arrString := strings.Fields(str)
fmt.Println(arrString) "Hello World    Beautiful World" // [Hello World Beautiful World] Now, my simple shell is already accepting and process the given params. Now, this command should be worked. $ ls -lah
total drwxr-xr-x iman  staff B Nov : .
drwxr-xr-x iman  staff B Nov : ..
-rw-r--r-- iman  staff B Nov : go.mod
-rw-r--r-- iman  staff B Nov : main.go
-rwxr-xr-x iman  staff M Nov : simshel 4280 5 160 6 19 48 6 192 6 11 41 1 38 6 11 43 1 606 6 20 11 1 2.1 6 19 49 Adding Exit Command But, this application is only worked for any built-in application that registered in the environment. Command like exit is not exist, because it is programmed in every CLI application. Then, I make a switch-case handler for each command that doesn’t have a built-in application in the system like the command. exit package main ( )

func main() { := bufio.NewReader(os.Stdin) {
		fmt.Print( )
		cmdString, := reader.ReadString( ) err != nil {
			fmt.Fprintln(os.Stderr, err)
		}
		err = runCommand(cmdString) err != nil {
			fmt.Fprintln(os.Stderr, err)
		}
	}
}
func runCommand(commandStr string) error {
	commandStr = strings.TrimSuffix(commandStr, )
	arrCommandStr := strings.Fields(commandStr) arrCommandStr[ ] { :
		os.Exit( ) }
	cmd := exec.Command(arrCommandStr[ ], arrCommandStr[ :]...)
	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout cmd.Run()
} import "bufio" "fmt" "os" "os/exec" "strings" reader for "$ " err '\n' if if "\n" switch 0 case "exit" 0 // add another case here for custom commands. 0 1 return Adding the Custom Command To add custom commands, I could simply add it to the switch-case handler. For example, I want to add a command like . This command does not exist in any CLI application out there. I want to make it like this: plus $ plus <br> 2 4 5 6 17 To make this, I just need to add a sum function and add the command case handler in the switch-case Conclusion In the end, it’s only a very simple application. But for sure, I learn a few things when making this. And also, when writing this, I found a similar article with this article (here: ). After reading that article, I’m thinking of discarding my draft. But, I’ve written a lot of explanation and example here, so then I decided to post it anyway XD. https://sj14.gitlab.io/post/2018-07-01-go-unix-shell/ Anyway, I’ve put the source code in my Github too here: , if just some chance happens, I will try to add some feature into it later. https://github.com/bxcodec/simpleshell *Indonesian version: * Update: Add another example of custom command https://medium.com/easyread/today-i-learned-belajar-membuat-aplikasi-interactive-shell-sederhana-di-golang-2ef013003393

Today I Learned: Making a Simple Interactive Shell Application in Golang

Coincidence is God’s way of remaining anonymous.-Albert Einstein Blockchain could be more universal than The Theory of General Relativity. In fact it could be the solution to the life’s biggest unanswered question as to How Life works, why does the universe behave the way it does. While Albert Einstein explains that all motion must be relative to a frame of reference and that space and time are relative, rather than absolute concepts. Einstein’s theory explains the how and the what but not the why ? defined I have always been intrigued by the Hindu Philosophy of which explains that the universe is largely the result of three different cosmic forces , the creator represented by the deity Brahma, the preserver represented by the deity Krishna , and the destroyer represented by the deity Shiva. Time and again these forces take the form of different avatars to manifest themselves and forward their respective agendas, thereby, keeping the universe in a state of equilibrium. Trimuti For the purpose of simplicity , we will observe this phenomenon at three different levels of existence : · The Human Body · Life at Large. · Commercial Transactions. The Human Body : The creator or Brahma is in essence the soul, which gives life to what is otherwise just Earth. The preserver or Krishna exists in the form of the biological anatomy or the underlying principles of the functioning of the human body. According to me, The Human Body is network of blockchain ecosystems interacting with each other and the external environment with an extremely complicated smart contract. I know these seems rather ridiculous yet funny at the same time but trust you me the explanation further might be able to shed some light. How does a blockchain network work- A network of individual peers interact with each other to attain the same goal.The system scans itself regularly to ensure each peer is functioning properly and if not, is corrected.If majority of the peers get corrupt, the blockchain fails. Much like the above, every organ functions in absolutely the same manner. A network of individual cells interact with each other to attain the same goal.The system scans itself regularly to ensure each cell is functioning properly and if not, is corrected.If majority of the cells get corrupt, the organ fails.Each organ system is therefore a network of interoperable blockchain networks and the human body an even more complex network of blockchain networks. Life at Large : When we talk about life at large, the modern day equivalent of brahma is man himself.They say that everything that we see and use today was first conceived simply in the form of an idea in the human brain. Much like a blockchain network, the creative force or initiation of a transaction with the rest of the environment first affects and needs validation from people( closest to you in life**(network)**, peers) Krishna or the preserver is again the underlying principle of the basis of which the universe works. Functions of the universe like success and fortune and their negative equivalents are distributed based on complex interactions between individual ecosystems each governing a small part of this giant moving mechanism. To be specific would limit the scope , however we can again see the existence of various governing principles also used on blockchain networks like the proof of work, stake , authority and many others to come. Life is but a sum of all your choices.Every choice you make in life is a real time implementation of proof of stake and how you arrive at consensus for choice in life. Commercial Success is largely driven by the blockchain consensus mechanism of proof of work. While things like the justice system are based on proof of authority. The consequences or the awards and punishments distributed by virtue of this principal are essentially the manifestations of shiva or the destroyer. The unique outcome of any event has an opportunity cost , in essence it destroys the parallel lives that could have been lead based on any outcome other than the unique outcome that occurred. Commercial Transactions : The various stakeholders in the market place play the role of the creative force or Brahma. Until now the businesses worked and interacted with each other based on these mystical power called trust. Blockchain removes the need to do that. It provides a secure trustable mechanism for awards to be distributed based on predefined terms.Every business contract can be represented in the form of a blockchain network, of-course varying in types and consensus algorithms based on use case. Shiva manifested itself in the form of various changes in technology and ideas which change the scope of commercial transactions forever. We are aware of the impact of things like mechanisation , automation , the internet on commercial transactions as we know it. Satoshi , an incarnation of Shiva decided to introduce blockchain and change the per-view of commercial transactions completely. While it destroys industries like accounting and reconciliation it gives scope to absolutely new types of industries like the blockchain industry itself. I don’t know about you , but Satoshi Nakamoto definitely holds a spiritual super powerful or as the common man would say Godly presence in my life.

Why Satoshi Nakamoto could be God ?

According to 2017, Microsoft’s Visual Studio Code tops the list of Which implies that there are a lot many developers who absofreakinlutely love VS Code. Here I have a list of extensions which might not make you a better developer, but for sure would make you feel like one! Octoverse Projects with the most contributors. Image from https://wallup.net/code-microsoft-visual-studio/ A nifty little command would get me the list of VS code extensions I already have installed $ code --list-extensions alefragnani.project-manageraaron-bond.better-commentseamodio.gitlenseg2.vscode-npm-scriptformulahendry.code-runnerjamespgilbert.comment-labelschristian-kohler.npm-intellisenseshardulm94.trailing-spacessteoates.autoimportstreetsidesoftware.code-spell-checkerwhtouche.vscode-js-console-utilsxabikos.JavaScriptSnippets A wise man once said : GIFs and JPEGs speak louder than words NPM Intellisense Git Lens NPM Scripts Code Runner Trailing white spaces "editor.trimAutoWhitespace": true,"files.trimTrailingWhitespace": true, Image by niichie Auto import Code spell checker Console utils Javascript Snippets imp→ import fs from 'fs';imn→ import 'animate.css'imd→ import {rename} from 'fs';ime→ import * as localAlias from 'fs';ima→ import { rename as localRename } from 'fs';enf→ export const log = (parameter) => {console.log(parameter);};edf→ export default (parameter) => { console.log(parameter);};ecl→ export default class Calculator { };ece→ export default class Calculator extends BaseClass { }; Project manager Comment labels Better comments A few more, particularly for ng fans : Angular v5 snippets Angular2 inline Angular2 material Other worthy mentions which either couldn’t make it to the top 12s or were too obvious : , , , , . gitlink esLint chrome-debug yarn Bracket pair Colorizer

Dope VS Code extensions for a Javascript developer

Excerpts from my experience at the AWS Summit in NYC! As a fresh Computer Science graduate working at a , attending my first ever tech summit was a pretty big deal. This article isn’t a step-by-step guide to those attending their first conference, but I hope my first experience can help you in preparing for yours! startup I traveled to New York City for the AWS Summit on 14th August 2017, along with my mentor and ’s Chief of Engineering . Since ’s infrastructure runs on Amazon Web Services, we thought this seminar would be a good way to quickly augment my AWS knowledge, and grasp new concepts and practices which may enable us to optimize our usage of AWS offerings, and build better solutions. You may want to pick your conferences based on the scope of your work and personal/professional interests. You can find most upcoming tech conferences around you on Eventbrite! BioBright Ryan M Harrison BioBright future Talks & deep dives at the AWS Summit. One of the most important aspects of a conference: the sessions, deep dives, and hands on labs. There are always multiple sessions at the same time, and if you go in unprepared, you are probably gonna miss out on some great talks and workshops. It’s important to go over the schedule, pick the talks you want to attend, and read up on topics you’re interested in learning about. The AWS Summits App(most tech conferences have their own apps) helped me go over the summit schedule, add particular events to my calendar, and set neat reminders. If you’re attending as a team, it might be a good idea to attend different talks which occur simultaneously. I attended sessions on Taking Apps from Monolith to Microservices by , EC2 Instances, Performance Optimization & Best Practices by Adam Boeglin, Object Storage: Amazon S3 and Amazon Glacier by Marc Trimuschat and Thomas Fuller, and a Deep dive on Amazon Aurora by Kevin Jernigan. You can read more about these talks . Abby Fuller here A lot of techies may opine that the most important aspect of these conferences is the opportunity to network. For a first-time conference attendee, this might seem intimidating. I have never been comfortable walking up to people and starting conversations, and there I was, a recently graduated Software Engineer walking among experienced engineers, solution architects and tech evangelists, and I had to try and speak with them?! I found that it wasn’t as terrifying as I visualized it, but it was still pretty nerve-wracking to begin with. I initiated conversations with fellow attendees at the very first session, and “small talk” was my savior. The ‘fresh graduate eager to learn’ card helped me a few times, and I ended up having meaningful conversations with most senior developers I approached. I also happened to visit a few vendor stalls at the summit, where I often asked the representatives to direct me to their engineers/architects. I had great conversations with people at , , Chef, and . Some of them even took the time to demo their products and give a brief overview of how these initiatives might help us at BioBright. What’s easier than talking to experts who were there just to answer questions from people like you? At the end, you walk away having learnt something new, and also some cool ! The AWS Experts booth and the Dev Lounge proved to be great platforms for junior devs like me to learn more about best practices, AWS offerings and their use cases, and certifications paths, directly from members of the Amazon Web Services team. MongoDB Redis Labs Datadog HQ swag A long day full of sessions, deep dives, hands-on labs, and other events came to an end with the happy hour, where people unwind and talk freely about work, life, beer, and all things tech. This is where you really get to connect with people, and learn more about their work, ideas, and passions. If you’re lucky, you’ll meet experts who are more than willing to drop some ! knowledge bombs All in all, the experience was quite awesome. With the exception of a , most senior techies are quick to empathize with junior developers, since most of them have been in your shoes. Use this to your advantage, but don’t be naive. Build meaningful conversations with the intent to learn, exchange ideas, and people will reciprocate. When it’s all said and done, write your first Medium post describing your first tech conference, then go plan and prepare for your next one! After all, it’s only gonna get better with each experience. I mean, it’s got to, right?! few

Stories, News & Mentions about TRIMDU

Trimdu’s Stories on HackerNoon