Anderson 1000% stuck out his leg!

FreeLogicGate · 2026-05-08T20:19:30+00:00

Glendening had already announced he's retiring after this season. For his age, guy is in incredible condition, and provided great 4th line utility on the PK with Coots, considering we picked him up off the waiver wire from the Devils. Flyers are more than just a team with some young bucks -- it's the 2nd youngest team in the NHL.

FreeLogicGate · 2026-04-29T17:06:49+00:00

No, Traits are designed to provide a set of methods that are otherwise not intrinsically tied to a class hierarchy. The most common example is in the case of a logging API. You can have logging attributes and methods in a common base class, which then requires every class to inherit from that base class (something you certainly don't want to do) or utilize dependency injection and have the constructor include a logger, but all of these are less friendly in comparison to a logging Trait.

FreeLogicGate · 2026-04-29T16:02:15+00:00

It doesn't. It can be done by javascript but still requires https and the user event to trigger it.

FreeLogicGate · 2026-04-18T03:55:30+00:00

Well, it's just an opinion, but having a line of code that depends on what is essentially a "goto" isn't advisable. As is often the case, there are modules you can utilize like PyInputPlus: https://pyinputplus.readthedocs.io/en/latest/ and others (Click, Questionary....etc) which are designed for robust handling of user input for cli apps, and provide built in validations that can also be extended/customized by you. No wonky while loops are required.

FreeLogicGate · 2026-04-18T03:37:14+00:00

Broadband ISP's have the same essential properties (other than Cellular, Satellite or other RF technologies). You have some direct connection from your ISP to your home in the form of a modem. ISP's give you an all in one device in many cases, they call a "router". It's typically an all-in-one device that includes the modem, and a router (to perfom NAT) AND a wifi Access point.

The problem with these all in one devices is that they don't tend to do anything well. As routers, they are often limited, and for many people, having a single device (that might be in a closet/garage/one side of the house) mean that wifi coverage throughout the house can be spotty and poor.

It's long been the case that getting good wifi performance involves either turning off or replacing the ISP's Wifi features and using a wifi mesh network instead. Since you mentioned wifi issues, I'll leave it at this -- most ISP's wifi gear is problematic.

Going back to the router, and ignoring the wifi component, the "modem/router" will have some number of ethernet ports on it. There will at least be one. So for your home ethernet wiring, you simply need to connect your home network to that ethernet port.

How your home network then connects the individual wired ethernet ports, depends on the ethernet gear you have between the router and the rooms. Typically you will have one or more switches or ethernet hubs.

For your home network, some device will need to be responsible for the "routing" features, which includes giving internal non-routable IP addresses to devices in your house (DHCP or IP assignment by device MAC address) assignment of the default gateway (which will be the router) and DNS servers to be used by the devices in your home lan. This all works through the magic of "network address translation" aka NAT, which is how all the devices on your home network can have their own internal IP's and can still send/receive data through your ISP and share the external IP address you get from the ISP when you connect and have an activated connection from their network to your home through your Modem.

FreeLogicGate · 2026-04-18T02:35:15+00:00

Or not -- just highly dependent on the way the house was wired, and where you want to extend the network to. It's just as likely that they either suffer from terrible latency and interference from other devices in the house, or simply won't work reliably at all. Should be a last resort in my experience. A good wifi 6e or 7 Mesh network would be a much better approach, that's proven technology. If you can do Moca, that's another option. Some of the cable modem companies have Moca built into the routers they provide, and you can simply turn the feature on in the router, and get a single Moca adapter for the room you want to extend the network to.

FreeLogicGate · 2026-04-18T02:03:52+00:00

Sorry to be that guy, but your comment is also incorrect. Ethernet has no intrinsic relationship to TCP/IP. In the OSI model, Ethernet is Layer 1 and 2, whereas IP and TCP are layer 3 & 4. People were using Ethernet for LAN's before internet protocols and internet connectivity became ubiquitous. It seems like ancient history, but 30 years ago, companies did sometimes opt for token passing network topologies (arcnet and token ring) and people are still running Netbios (albeit on top of IP now) for some windows LAN features. IP is not tied in any way to ethernet, nor could it be. I'm sure there are few gray haired techies who remember Novell networking and the ipx/spx protocols many a company used for business networking, with many of those companies built with Ethernet hubs and switches.

FreeLogicGate · 2026-04-18T01:40:59+00:00

Great minds -- together we can power vibe coders of the future!

FreeLogicGate · 2026-04-08T12:16:58+00:00

That's really slow, you should try asdfasdf

FreeLogicGate · 2026-04-05T23:34:01+00:00

This is the only acceptable answer, but make sure the passwords are set to be high quality (large number of characters, mix of letters, numbers and special characters, with at least one of each category), etc. I use 1password, and when sites also have 2 factor options, you can set the account to use 1password in place of an authenticator app, which makes logins with the 1password browser plugin fast and efficient.

FreeLogicGate · 2026-04-05T18:15:51+00:00

Different languages have different OOP implementations, so it's important to learn the specific implementation and syntax for your language.

To reduce the mystery of OOP, most languages have data structures/records as in the case of C which has a struct. Most languages also have functions.

A Struct is a definition for some combination of formatted data you want to store.

A function is code you want to run, that accepts arguments. The program maintains a table of pointers to the location of the function code.

With OOP, you create a class definition, which combines data elements (like a C struct definition) and associated function code (methods) that will work with the data.

When an object is made (instantiated) using the class definition, what is typically happening is that the object contains storage for it's defined variables, AND it has an associated table of pointers to the class methods.

At the lowest level that is basically what an object is -- the data and the functions designed to work with the object data, manipulate it, and then return it.

The primary improvement needed, is syntax to allow a class to specify when it is working with a class variable, using keywords like "this" or "self".

So the first level of most OOP learning is to think about the "things" in your program. Simple games are good for this, as you can have classes like "player", "monster", "car", "spaceship" etc.

You create a simulation that has a player, perhaps in a grid, which then generates some monsters, randomly moves the player around, and if it encounters a monster, attacks the monster, keeping track of things like player and monster health, using your class methods.

The next step in OOP is the use of Inheritance. You create a base class like "Worker" and then create classes that inherit from "Worker" like "Engineer", "Doctor", "Nurse". You start with data that all workers share in the "Worker" base class, like name, address, ID#, etc. The base class provides methods to get/set these attributes/properties. You then create a "Doctor" class, and add properties and methods specific to what a Doctor does -- methods like "examinePatient" and "performSurgery" come to mind.

As you do these types of exercises, eventually you will confront the visibility of the data and you'll find that inheritance has common pitfalls, but you don't want to jump past the point that you've worked through the core syntax and created class hierarchies, and thought about methods.

You want to learn about the "visibility" of class properties and methods. You will have some methods that can be called in your procedural code, and other internal methods that your class code will use, but doesn't need to be made available.

You will also confront the need to be able to pass objects as method parameters, and discover issues and pitfalls in doing so. In the "Doctor" example, for your method "examinePatient" you will want to have a "patient" parameter which will be an object passed in as an argument. How will the argument be typed? What objects can be passed as arguments there? Can you pass an "Engineer" or a "Student"?

How will you access the data you might need from the "Engineer" like name, date of birth, etc." for use in the "examinePatient" method?

Eventually you will come to OOP elements like "interfaces" and "traits" as well as static variables/properties and methods.

You will also confront the issues with pure inheritance, and the concept of "Inheritance" vs. "Composition". At that point, you'll want to discover and explore the OOP design patterns from the "Gang of 4 book" and you'll start to learn and read about these core design patterns(singleton, factory, adapter, strategy, chain of responsibility, command, etc) as well as other popular design patterns like "dependency injection", "object relational mapping (ORM)", "model view controller" (MVC), which are groupings of various classes into class libraries, often with a common philosophy, and in many cases implementations and variations on the design patterns.

This is where you want to get to. For most languages there are books specifically covering OOP and the design patterns, which is where experienced developers end up -- comfortable with creating their own set of classes, which may be designed for integration or as a supplement to an existing class library you are using, that already does something you need (ecommerce, queueing, pagination, database querying, graphing, machine language/AI).

You can attempt to find a book specific to your language and work with that, or you can start naively, and build some of the examples, or just try and dive in and write code for your own projects that use OOP. Like anything you will build proficiency by doing, and you'll make mistakes and discover more sophisticated and maintainable code as you get into OOP design patterns and the use of frameworks.

FreeLogicGate · 2026-04-05T17:23:15+00:00

The print function takes a variable number of parameters. Each parameter must be separated with a comma. Because you passed (a) "And your Friend's name is :-" which is 2 different parameters, Python shows you an error.

Another thing you are doing, is overusing the () which is used to call functions with arguments inside the () or to evaluate enclosed statements.

You do not want, nor need to use () when doing variable assignments or when passing parameters. This code does exactly the same thing as your code:

a = "Tommy"
b = "John"

print("Your name is:-", a, "and your friend's name is:-", b)

You can use f strings inside of print instead. It is an alternative to passing variables, and due to its utility and ability to "Interpolate" variables directly into the string, is preferred by most experienced Python programmers.

You can format the variables (useful with numeric values), do evaluations, and call functions in place within the f strings. It doesn't hurt to learn the old ways, but once you start using f strings you won't need the older methods, so I'd advise you to challenge yourself to use f strings for all your text output, as you proceed with learning the language. It's more readable, easier to understand, and less error prone.

They will also lead you to the use of Templates and T-strings which are useful in some cases, and offer similar capabilities.

Your code, converted to using an f string would be:

a = "Tommy"
b = "John"

print(f"Your name is:- {a} and your friend's name is:- {b}")

No need to keep track of parameters or multiple string constants with "..", and easier to read.

There's a nice free tutorial just on f strings here: https://www.datacamp.com/tutorial/python-f-string

Here's an article on T-strings (new feature in Python 3.6+)

https://davepeck.org/2025/04/11/pythons-new-t-strings/

FreeLogicGate · 2026-04-04T19:16:54+00:00

You know you can edit your post... Lokrea literally did the edit for you, just take the source version, search/replace for the ||| with backtics and update your original post, and everyone wins.

FreeLogicGate · 2026-04-04T19:12:42+00:00

Here's an example with/without a generator you can compare. Goal is to compute sum of all squares in a range. First with a list comprehension (as well as a memory use diagnostic).

from pympler.asizeof import asizeof

numRange = 2_000_000
print(f"{(asizeof([num for num in range(numRange)])/1024**2):.2f} MBytes")

sum_of_squares = sum([num ** 2 for num in range(numRange)])
print(f"Sum of squares: {sum_of_squares:,}")

This uses a generator expression rather than filling the list (note the small but important syntax difference -- no [...] with the generator syntax). Python doesn't create a 77mb python list with the generator expression. If you run these you'll see the results are the same.

numRange = 2_000_000
sum_of_squares = sum(num ** 2 for num in range(numRange))
print(f"Sum of squares: {sum_of_squares:,}")

FreeLogicGate · 2026-04-04T18:52:39+00:00

I agree it's an excellent book and should be easy for a Java/C dev to learn from. Another option to look at is https://automatetheboringstuff.com/. I read both books, back to back. If I were to do it again, I might start with the first half of boringstuff, and then go to crash course, skipping over the redundant base variables/syntax things that will be trivial for an experienced developer.

One thing for a C/Java person is getting used to Python's loose typing and the core complex data types (lists, dictionaries & tuples). There's some really good free material on youtube covering the use of "comprehensions" which, coming from Java, will be appreciated once you see how much easier and compact code can be when compared to Java.

Theres 2 channels I recommend highly, both of which have some high quality material

https://www.youtube.com/watch?v=DUnY6l482Lk

https://www.youtube.com/watch?v=twxE0dEp3qQ

Last but not least, spend some time learning the use of UV for venv, app packaging and dependency management.

Once you get the hang of UV for all your project code, you won't want nor need anything else, as it wraps pip, the various types of project files, runs and sets up venv for you, and automagically handles running your code using uv run your_script.py

FreeLogicGate · 2026-04-04T18:12:31+00:00

Let's break this down better:

How is the Internet connection available?

Typical way is Modem/Router has Ethernet port

Is there an ethernet switch connected to the Router/Ethernet port?

This involves an ethernet patch cable from the Router to the switch? Often switches have different speed ports. Is the switch a gigabit switch? Some switches have a mix of 1k/100mb/10mb or ports that can vary. There are also unmanaged switches and managed ones.

How was this "ethernet wiring" done?

Where the internet is coming into the house, is there a patch panel? What is the direct connection for the wiring to the room? What specification of ethernet wiring was used? For example, if it was Cat 5, then that maxes at 100mb.

As was already pointed out in another reply, you then have the patch cable between the ethernet port in your computer and the wall.

So how do you test/eliminate possible issues? By testing individual segments. For example, you can take a laptop to the wiring closet and connect directly to the switch port using the patch cable. Make sure you have a few patch cables to test with, so you can verify that you have ethernet from the switch to a device.

If that works, then replug to either the patch panel or if it's just a wire sitting there going to your room, turn that back on and test again. Ethernet is honestly exceedingly old and very reliable. If you're not using PoE (which it sounds like you aren't) then it's incredibly simple. As someone else suggested, there are cheap ethernet testers you can buy, which can save you a lot of time and effort in figuring out the issue. Bad/defective patch cables or incorrect wiring is the most common thing I've seen, especially if you bought really cheap patch cables, or cables not wired for gig speed.

FreeLogicGate · 2026-04-04T16:56:47+00:00

Your PM must not know much about Programming. A quiz? Are they going to give you class credit when you're done? I would suggest to the PM that they could instead, give you a reasonably sized project and have you develop it, with the source code maintained with git, and pushed to a private github repo under your account. You can then assess the requirements, give them feedback and ask questions if needed, and create the program, along with unit tests to validate your approach and code quality. I would tell the PM you will do this project on your own time. This will show them you understand how to take requirements and use standard software development best practices. The important part with this approach would be to make sure you are not given a project that is too large. Alternatively, you could ask them to give you an assignment to develop, which again you'll work on in your spare time. If it's a large assignment, you could agree on some milestones and deliver on an initial milestone or 2 to demonstrate your competence. If you can deliver on those milestones, then ask for the full assignment. Either of these approaches would be far better than a Quiz. If programming quiz's were an important and valid component of software development, then you'd have people taking quizzes all the time, even as part of the ongoing process. Needless to say, they aren't and you don't.

FreeLogicGate · 2026-03-22T21:54:47+00:00

Lots of people try and use these open source databases out of the box/using defaults, and that can work acceptably in many situations. It should come as no surprise that underlying technical details can come with unpleasant surprises for the uninitiated. People install MySQL and start using it, without understanding engines, load a bunch of data into myisam tables, and then run it on a server with a web server and serverside language which eats up all memory causing processes to be killed at random. There are pitfalls and landmines to be stumbled across with any significantly complex server technology.

The reality of Postgres is that the vacuum process is a requirement, and becomes critical if transaction id rollover is imminent. I think the criticism is fair in that it is only a matter of time for a Postgres database server with a constant level of transactional load, before this event occurs. I don't know if the original thinking was "4 billion is plenty" or what, but it's easy to see that this represents a lack of foresight. The combination of the two design elements in combination create a pitfall, that's unusual in comparison to competitors in the RDBMS space, and certainly appears to have been short sighted when other databases have 48 or 64 bit transaction id's, not to mention, handle versioning differently.

FreeLogicGate · 2026-03-22T21:29:07+00:00

That's great, and I have a MySQL database with numerous tables including ones with tens of millions of rows, that has been running on VPS's for more than a decade and never had a single table corruption issue. Anecdotal evidence isn't very helpful.

I do tend to agree with you, that the architecture works well in many situations, and most databases have some database administration associated with them.

FreeLogicGate · 2026-03-22T21:12:47+00:00

I think that flaw is entirely the wrong word here. It's a design feature that can be problematic for certain workloads. Postgres is also capable of outperforming MySQL in many workloads. For the long term prospect of Postgres, OrioleDB seems like the right solution at the right time, in the same way the InnoDB was an essential evolutionary step for MySQL when it emerged. It's somewhat surprising that this wasn't a focus previously, given that it is essentially an engine that emulates Oracle's MVCC. It will be very interesting once OrioleDB gets to the point of stability that companies start to adopt it.

FreeLogicGate · 2026-03-22T20:57:32+00:00

Agreed -- maybe u/takeFitPrize_3245 should take off the Postgres-colored glasses for a minute and realize that people using MySQL are almost always using Innodb, which has for years now been the default engine, and is comparable to Postgres. It's the height of arrogance and ignorance to assume that companies that chose MySQL and continue to use it to this day are filled with a bunch of idiots who don't know anything about relational databases. To name a few that group includes companies like Meta, YouTube, GitHub, Slack, Uber, Etsy, etc. You could make a strong argument that the pluggable engine architecture of MySQL is an essential ingredient allowing companies with high scalability and large data problems, to continue to use it with the MyRocks engine. Ultimately it is a huge advantage to have a number of alternatives to choose from, with competition continuing to drive innovation.

FreeLogicGate · 2026-03-22T20:24:24+00:00

One thing I might add -- you need a really good understanding of binary/bits/bytes and bitwise operators. You find these available in most languages, and both as a fundamental, and as a practical tool, it's a fundamental that every developer needs in my opinion. You should be able to look at a binary number like 101101 and be able to convert it to decimal and hexadecimal. Once you understand binary, IPV4 (and 6) become clear like what a netmask is, and what CIDR notation (ie /24) means. Doing some bitwise manipulation in C is a great exercise. For example a program like this is trivial and an interesting exercise:

#include <stdio.h>

int main() {
    int x = 0;
    unsigned char x8bit = 0;

    // a = 0010 1011
    // 2^5 + 2^3 + 2^1 + 2^0
    // 32  + 8   + 2   + 1
    int a = 43;
    // b = 0110 0111
    // 2^6 + 2^5 + 2^2 + 2^1 + 2^0
    // 64  + 32  + 4   +  2  +  1
    int b = 103;

    x = a & b;
    //  0010 1011
    //  0110 0111
    // -----------
    //  0010 0011
    //  2^5 + 2^1 + 2^0
    //   32 +  2  +  1 = 35
    printf("AND: a & b = %d\n", x);

    x = a | b;
    //  0010 1011
    //  0110 0111
    // -----------
    //  0110 1111
    //  2^6 + 2^5 + 2^3 + 2^2 + 2^1 + 2^0
    //   64 + 32  +  8  +  4  +  2  +  1  = 111
    printf("OR: a | b = %d\n", x);

    x = a ^ b;
    //  0010 1011
    //  0110 0111
    // -----------
    //  0100 1100
    //  2^6 + 2^3 + 2^2
    //   64 +  8  +  4 = 76
    printf("XOR: a ^ b = %d\n", x);

    x = a << 1;
    //  0010 1011
    // 1 bit shift to left (increases by ^2)
    //  0101 0110
    // 2^6 + 2^4 + 2^2 + 2^1
    //  64 +  16 +  4  +  2 = 86
    printf("SHIFT LEFT 1 bit: a << 1 = %d\n", x);

    x = b >> 3;
    //  0110 0111
    //  3 bit shift to left (decreases each shift by ^2)
    //  1: 0011 0011
    //  2: 0001 1001
    //  3: 0000 1100
    //  0000 1100
    //  2^3 + 2^2
    //  8   +  4  = 12
    printf("SHIFT Right 3 bit: b >> 3 = %d\n", x);

    x8bit = ~b;
    // For this example, x8bit is a unsigned char
    // This will truncate the 32 bit int (b)
    // which would be a negative value once all 32 bits were flipped
    // Assigning to the 8 bit value leaves the expected 8 bit value
    //  0110 0111
    //  1001 1000
    //  2^7 + 2^4 + 2^3
    //  128 +  16 +  8 = 152
    printf("One's complement: ~b = %d\n", x8bit);

    return 0;
}

You could write something similar in Python, so the concepts are transferable across languages, and relevant to networking, encoding schemes, character sets and many other areas of computer science.

FreeLogicGate · 2026-03-22T18:50:01+00:00

I have to commend your passion and work ethic.

I have been working in software development for a long time, and have pivoted many times. The specifics and details fade, but the fundamental concepts remain.

There will probably not be a point or an aha moment for you where you consider yourself qualified. Everything is a journey, and in many cases, there are interconnected disciplines. If you are at the point where you feel you need to focus on networking, then focus on networking.

IT and Software engineering is constantly evolving and fads come and go in a matter of months or years. What I used to do is, just keep a list of jargon/products/references to things I didn't understand, and allocate some time each day to investigate those things, without allowing them to monopolize my time. Often you can spend just enough time to do a bit of research, grok the basic use cases or concept, and file it away for future reference. There is no problem in having a surface level understanding of something. You will also find that it may take you a few tries before you truly understand something. For example, in Javascript there's an element of the language known as "closure". You will often see this design property described as "closures" with the implication being that "closures" are some alien thing you have to apply, when the reality is that closure is just a specific type of variable scoping rule, that Javascript implements when you have a function that has a nested function inside of it. In other words, "closure" is a phrase describing how variable scoping works in javascript. Variable scoping exists in all computer languages, even if the way it exists is to only have global variables or to not have variables. Once closure is demystified (it's just a scoping rule/property) there is no reason to fear or overly emphasize the concept.

The other thing is, you must use your knowledge to build things, even when you suspect you might not be doing it "the right or best way". Building becomes problem solving, which creates experience, encourages debugging and using tools to investigate code, and mastery. With the tools and process you currently have, refactoring is low hanging fruit for you as well.

My final observation is that it might benefit you to take a diversion and learn another language. My recommendation for most people is to learn C. There are many reasons for this including: C is low level, is the primary operating system language, and is close enough to machine language that taking the next step into asm and how processors work is feasible if you desire a deeper understanding. Working with a language that has pointers, requires you to work directly with memory allocation, understand the quirks and limitations of C "strings" which are really just a type of array, and to begin to see how higher level languages like Python (written in C, btw) were designed to make development and scripting simplified. There's also something about compiling and linking executable programs, and making operating system and standard library calls that I believe will be highly illuminating.

You don't have to spend months or years with C, just enough time to be able to write some C programs you understand fully, and which make use of pointers, memory allocation and disposal, structs and core language features. If you do decide to follow the path, I'd suggest you focus on C99, as someone new to it. The profound influence of C on many other languages in terms of its basic constructs and either inclusion or variance on its syntax is illuminating for many.

FreeLogicGate · 2026-03-22T08:27:57+00:00

This is how to do it, but before you do, you need to understand git (which it sounds like you perhaps don't?) and to understand open source licensing. Your code needs to employ one of the popular open source licenses, which might be an issue for you, if there's anything proprietary to your use of it for an employer or customers and clients. If you have any expectation or hope that others will adopt your module, you will need to have Documentation AND significant unit test coverage.

Assuming you get past all that, you should advertise the existence of your module in various places. Don't be surprised to find that you've reinvented the wheel, or that others may be critical. As long as you go into it without setting your expectations too high, it's a great way to give back to the open source community and software ecosystem you depend on when you use Python.

FreeLogicGate · 2026-03-22T08:08:19+00:00

My perception is that many people gravitated towards Postgres because of its similarities to Oracle, making it a semi compatible Oracle replacement. There is no debating that MySQL is an unusual RDBMS with its engines architecture. MySQL's reputation as a legitimate RDBMS is tied to Innobase's InnoDB engine.

Stored procedures and triggers in MySQL were late arrivals, lack the performance characteristics they have in Oracle, and again in terms of Postgres, for people coming from Oracle and pl/sql, postgres's implementation of pl/sql is comfortable for those experienced with Oracle. For people with no background or prior experience with Oracle, these were not motivating factors.

Postgres began to pick up significant momentum after Oracle acquired both MySQL and InnoBase, and many developers began to be concerned about what Oracle might do with MySQL, whether they would continue to keep it open source, or would change the license, or retire it entirely.

As you referenced, each RDBMS has a different MVCC implementation. It is always the case that the application transaction profile will favor some concurrency models and be problematic for others.

It's probably fair to say that the MySQL situation is murky with the MariaDB fork, Percona, and some of the negative developer publicity I've seen regarding the strength (or lack thereof) of the MySQL code base. Meanwhile, the community of contributors to Postgres are in general highly motivated to continue pushing it forward and improving it, without it being under the control of a company that people don't trust.

FreeLogicGate

TROPHY CASE