Do you only have to pay the 10.000 and everything is covered or is there still more to pay per visit or procedure?
I started a new job this week, in the US, and for a family of four I'm going to pay $30,000 per year in premiums....only premiums.
Holy shit, thank you!!!
Logo on a sock that is 10 years old...anyone know the brand?
![](https://lemmy.world/pictrs/image/7011f017-5a9a-491f-a192-151d52cce143.jpeg?format=webp&thumbnail=128)
![](https://lemmy.world/pictrs/image/7011f017-5a9a-491f-a192-151d52cce143.jpeg?format=webp)
My wife doesn't recall where she got these but really wants another pair but I haven't been able to find this logo anywhere.
Yea, I am very confused by the headline. Maybe if it compared Openshift to Kubernetes...
hashicorp's APIs will be right at home at IBM. Right along with HCL. not a fan of either but have been forced to use them. this might bode well for my future if a pending license change is coming.
a fellow texan?
... and the output running through ChatGPT4
- What are Go routines, and how do they differ from threads?
Goroutines are lightweight threads managed by the Go runtime. The key differences between goroutines and traditional OS threads are:
- Lightweight: Goroutines have a smaller memory footprint (a few kB each) compared to OS threads, which allows you to spawn thousands or even millions of goroutines on a single machine.
- Dynamic Stack: The stack size of goroutines grows and shrinks dynamically as needed, whereas OS threads typically have a fixed stack size.
- Scheduling: Goroutines are multiplexed onto a smaller number of OS threads by the Go runtime scheduler, allowing efficient IO operations and CPU utilization without the overhead of thread context switching.
- How does Go’s garbage collector work, and how can it affect application performance?
Go uses a concurrent, mark-and-sweep garbage collector. This means it performs garbage collection in two phases: marking objects that are in use (directly or indirectly reachable) and sweeping (freeing) the objects that are not marked. The collector runs concurrently with the Go program, minimizing pause times. However, garbage collection can still affect application performance, particularly through:
- Pause Times: Even though Go's garbage collector is designed to be low-latency, the pause times can still affect performance-critical applications.
- CPU Overhead: The concurrent operation of the garbage collector consumes CPU resources, potentially competing with application threads.
- In Go, what is the ‘defer’ statement, and can you give an example of when it’s particularly useful?
The defer statement postpones the execution of a function until the surrounding function returns. It's particularly useful for cleaning up resources, such as closing files or network connections. Here's an example:
func readFile(filename string) (content string, err error) {
f, err := os.Open(filename)
if err != nil {
return "", err
}
defer f.Close() // Ensures that the file is closed when the function returns.
bytes, err := io.ReadAll(f) // As of Go 1.16, use io.ReadAll instead of ioutil.ReadAll.
if err != nil {
return "", err
}
return string(bytes), nil
}
- What is the biggest technical challenge you met when use Go for software development?
This can vary widely among developers, but common challenges include managing dependencies effectively, understanding and optimizing performance, especially in concurrent programs, and mastering Go's interfaces and type system for large-scale, modular design.
- How do you manage dependencies in a Go project?
Go uses modules for dependency management, introduced in Go 1.11. You can manage dependencies by:
- Using the
go mod init
command to create a new module. - Specifying dependencies in the
go.mod
file. - Running
go get
to fetch dependencies. - Using
go mod tidy
to remove unused dependencies.
- Do you have any working experience for using Helm chart to deploy software on Kubernetes environments?
Yes, Helm charts are a powerful way to manage Kubernetes applications. Helm helps you define, install, and upgrade even the most complex Kubernetes applications. Charts are easy to create, version, share, and publish — so start using Helm and stop the copy-and-paste madness.
- Explain how you monitor and troubleshoot applications running in Kubernetes?
Monitoring and troubleshooting applications in Kubernetes can be approached with tools like Prometheus for monitoring and alerting, Grafana for dashboards, and Fluentd or Elasticsearch-Logstash-Kibana (ELK) stack for logging. For troubleshooting, tools like kubectl
for inspecting cluster resources, and kube-state-metrics
for exposing state information are invaluable. Practices like setting up proper liveness and readiness probes, utilizing Horizontal Pod Autoscalers, and implementing effective logging and observability strategies are key.
- What tools or practices have you found most effective?
Effective tools and practices in a Kubernetes environment include:
- Infrastructure as Code (IaC): Using Terraform or similar tools for managing infrastructure.
- Continuous Integration/Continuous Deployment (CI/CD): Leveraging Jenkins, GitLab CI, or GitHub Actions for automated testing and deployment.
- Monitoring and Observability: Implementing comprehensive monitoring and logging with Prometheus, Grafana, and the ELK stack.
- Configuration Management: Using ConfigMaps and Secrets for configuration management in Kubernetes.
- How have you used Kubernetes to improve the scalability and reliability of software?
Kubernetes excels at managing the deployment and operation of applications at scale.
- Horizontal Pod Autoscaler (HPA) automatically scales the number of pods based on observed CPU utilization or other selected metrics.
- Self-healing: Automatically replaces or reschedules failed pods and nodes.
- Service Discovery and Load Balancing: Distributes network traffic to ensure stability and high availability.
- Rolling Updates & Rollbacks: Facilitates zero-downtime updates and easy rollbacks to previous versions.
Interview Questions from interview for Senior Developer at Hitachi Vantara
I had an interview with the hiring manager and these were the questions he asked. His accent was quite heavy so he also typed them for me in the VC chat window. I just copied/pasted from there.
What are Go routines, and how do they differ from threads?
How does Go's garbage collector work, and how can it affect application performance?
In Go, what is the 'defer' statements, and can you give an example of when it's particularly useful?
What is the biggest technical challenge you met when use golang for software development?
How do you manage dependencies in a Go project?
Do you have any working exp for using helm chart to deploy software on k8s env?
Explain how you monitor and troubleshoot applications running in Kubernetes?
What tools or practices have you found most effective?
How have you used Kubernetes to improve the scalability and reliability of an software?
Screenshots: https://imgur.com/a/jp5fm3U
Slot 1 is loaded with Bambu Labs Aero PLA. Slot 3 is loaded with support material for PLA. No issue loading and they are recognized correctly by the printer. I do a resync in Bambu studio and the results are the same as before the resync (and they are correct).
I have tried saving the slice, quitting Bambu Studio, turning off printer, turning on printer, loading Bambu Studio, and then replacing and end up at the same spot needing to select the slot that has Aero PLA.
Anyone know how to get around this?